feat: Refactor LLM router and integrate health check endpoint

- Simplified LLM call logic in llm_router.py, removing tool adapter complexity and enhancing error handling.
- Added health check endpoint to main.py for system status verification.
- Cleaned up router.py by removing unused imports and commented-out code, streamlining the structure.
- Updated docker-compose.yml to unify services under a single Lyra container, enhancing deployment simplicity.
- Created Dockerfile for unified container setup, including both Relay and Cortex services.
- Added QUICKSTART.md for improved onboarding and usage instructions.
- Implemented start.sh script to manage service startup and health checks.

.dockerignore

@@ -0,0 +1,52 @@
+# Git
+.git
+.gitignore
+
+# Docker
+docker-compose.yml
+Dockerfile*
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+.venv
+venv
+
+# Node
+node_modules
+npm-debug.log
+yarn-error.log
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+
+# Logs
+*.log
+logs
+
+# Environment
+.env.local
+.env.*.local
+
+# Backup directories
+*-old
+*-backup*
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Temp
+*.tmp
+tmp

DEPRECATED_FILES.md

@@ -1,91 +0,0 @@
-# Deprecated Files - Safe to Delete
-
-This file lists all deprecated files that can be safely deleted after verification.
-
-## Files Marked for Deletion
-
-### Docker Compose Files
-
-#### `/core/docker-compose.yml.DEPRECATED`
-- **Status**: DEPRECATED
-- **Reason**: All services consolidated into main `/docker-compose.yml`
-- **Replaced by**: `/docker-compose.yml` (relay service now has complete config)
-- **Safe to delete**: Yes, after verifying main docker-compose works
-
-### Environment Files
-
-All original `.env` files have been consolidated. Backups exist in `.env-backups/` directory.
-
-#### Previously Deleted (Already Done)
-- ✅ `/core/.env` - Deleted (redundant with root .env)
-
-### Experimental/Orphaned Files
-
-#### `/core/env experiments/` (entire directory)
-- **Status**: User will handle separately
-- **Contains**: `.env`, `.env.local`, `.env.openai`
-- **Action**: User to review and clean up
-
-## Verification Steps Before Deleting
-
-Before deleting the deprecated files, verify:
-
-1. **Test main docker-compose.yml works:**
-   ```bash
-   cd /home/serversdown/project-lyra
-   docker-compose down
-   docker-compose up -d
-   docker-compose ps  # All services should be running
-   ```
-
-2. **Verify relay service has correct config:**
-   ```bash
-   docker exec relay env | grep -E "LLM_|NEOMEM_|OPENAI"
-   docker exec relay ls -la /app/sessions  # Sessions volume mounted
-   ```
-
-3. **Test relay functionality:**
-   - Send a test message through relay
-   - Verify memory storage works
-   - Confirm LLM backend connections work
-
-## Deletion Commands
-
-After successful verification, run:
-
-```bash
-cd /home/serversdown/project-lyra
-
-# Delete deprecated docker-compose file
-rm core/docker-compose.yml.DEPRECATED
-
-# Optionally clean up backup directory after confirming everything works
-# (Keep backups for at least a few days/weeks)
-# rm -rf .env-backups/
-```
-
-## Files to Keep
-
-These files should **NOT** be deleted:
-
-- ✅ `.env` (root) - Single source of truth
-- ✅ `.env.example` (root) - Security template (commit to git)
-- ✅ `cortex/.env` - Service-specific config
-- ✅ `cortex/.env.example` - Security template (commit to git)
-- ✅ `neomem/.env` - Service-specific config
-- ✅ `neomem/.env.example` - Security template (commit to git)
-- ✅ `intake/.env` - Service-specific config
-- ✅ `intake/.env.example` - Security template (commit to git)
-- ✅ `rag/.env.example` - Security template (commit to git)
-- ✅ `docker-compose.yml` - Main orchestration file
-- ✅ `ENVIRONMENT_VARIABLES.md` - Documentation
-- ✅ `.gitignore` - Git configuration
-
-## Backup Information
-
-All original `.env` files backed up to:
-- Location: `/home/serversdown/project-lyra/.env-backups/`
-- Timestamp: `20251126_025334`
-- Files: 6 original .env files
-
-Keep backups until you're confident the new setup is stable (recommended: 2-4 weeks).

Dockerfile

@@ -0,0 +1,48 @@
+# Unified Lyra Container - Relay (Node) + Cortex (Python)
+FROM python:3.11-slim
+
+# Install Node.js, npm, and docker CLI
+RUN apt-get update && apt-get install -y \
+    curl \
+    docker.io \
+    && curl -fsSL https://deb.nodesource.com/setup_18.x | bash - \
+    && apt-get install -y nodejs \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# ============================================================
+# Install Python dependencies (Cortex)
+# ============================================================
+COPY cortex/requirements.txt /app/cortex/requirements.txt
+RUN pip install --no-cache-dir -r /app/cortex/requirements.txt
+
+# ============================================================
+# Install Node dependencies (Relay)
+# ============================================================
+COPY core/relay/package*.json /app/relay/
+WORKDIR /app/relay
+RUN npm install
+
+# ============================================================
+# Copy application code
+# ============================================================
+WORKDIR /app
+COPY cortex/ /app/cortex/
+COPY core/relay/ /app/relay/
+
+# ============================================================
+# Copy startup script
+# ============================================================
+COPY start.sh /app/start.sh
+RUN chmod +x /app/start.sh
+
+# ============================================================
+# Expose ports
+# ============================================================
+EXPOSE 7078 7081
+
+# ============================================================
+# Start both services
+# ============================================================
+CMD ["/app/start.sh"]

LOGGING_MIGRATION.md

@@ -1,178 +0,0 @@
-# Logging System Migration Complete
-
-## ✅ What Changed
-
-The old `VERBOSE_DEBUG` logging system has been completely replaced with the new structured `LOG_DETAIL_LEVEL` system.
-
-### Files Modified
-
-1. **[.env](.env)** - Removed `VERBOSE_DEBUG`, cleaned up duplicate `LOG_DETAIL_LEVEL` settings
-2. **[cortex/.env](cortex/.env)** - Removed `VERBOSE_DEBUG` from cortex config
-3. **[cortex/router.py](cortex/router.py)** - Replaced `VERBOSE_DEBUG` checks with `LOG_DETAIL_LEVEL`
-4. **[cortex/context.py](cortex/context.py)** - Replaced `VERBOSE_DEBUG` with `LOG_DETAIL_LEVEL`, removed verbose file logging setup
-
-## 🎯 New Logging Configuration
-
-### Single Environment Variable
-
-Set `LOG_DETAIL_LEVEL` in your `.env` file:
-
-```bash
-LOG_DETAIL_LEVEL=detailed
-```
-
-### Logging Levels
-
-| Level | Lines/Message | What You See |
-|-------|---------------|--------------|
-| **minimal** | 1-2 | Only errors and critical events |
-| **summary** | 5-7 | Pipeline completion, errors, warnings (production mode) |
-| **detailed** | 30-50 | LLM outputs, timing breakdowns, context (debugging mode) |
-| **verbose** | 100+ | Everything including raw JSON dumps (deep debugging) |
-
-## 📊 What You Get at Each Level
-
-### Summary Mode (Production)
-```
-📊 Context | Session: abc123 | Messages: 42 | Last: 5.2min | RAG: 3 results
-🧠 Monologue | question | Tone: curious
-
-====================================================================================================
-✨ PIPELINE COMPLETE | Session: abc123 | Total: 1250ms
-====================================================================================================
-📤 Output: 342 characters
-====================================================================================================
-```
-
-### Detailed Mode (Debugging - RECOMMENDED)
-```
-====================================================================================================
-🚀 PIPELINE START | Session: abc123 | 14:23:45.123
-====================================================================================================
-📝 User: What is the meaning of life?
-────────────────────────────────────────────────────────────────────────────────────────────────────
-
-────────────────────────────────────────────────────────────────────────────────────────────────────
-🧠 LLM CALL | Backend: PRIMARY | 14:23:45.234
-────────────────────────────────────────────────────────────────────────────────────────────────────
-📝 Prompt: You are Lyra, analyzing the user's question...
-💬 Reply: Based on the context provided, here's my analysis...
-────────────────────────────────────────────────────────────────────────────────────────────────────
-
-📊 Context | Session: abc123 | Messages: 42 | Last: 5.2min | RAG: 3 results
-────────────────────────────────────────────────────────────────────────────────────────────────────
-[CONTEXT] Session abc123 | User: What is the meaning of life?
-────────────────────────────────────────────────────────────────────────────────────────────────────
-  Mode: default | Mood: neutral | Project: None
-  Tools: RAG, WEB, WEATHER, CODEBRAIN, POKERBRAIN
-
-  ╭─ INTAKE SUMMARIES ────────────────────────────────────────────────
-  │ L1  : Last message discussed philosophy...
-  │ L5  : Recent 5 messages covered existential topics...
-  │ L10 : Past 10 messages showed curiosity pattern...
-  ╰───────────────────────────────────────────────────────────────────
-
-  ╭─ RAG RESULTS (3) ──────────────────────────────────────────────
-  │ [1] 0.923 | Previous discussion about purpose...
-  │ [2] 0.891 | Note about existential philosophy...
-  │ [3] 0.867 | Memory of Viktor Frankl discussion...
-  ╰───────────────────────────────────────────────────────────────────
-────────────────────────────────────────────────────────────────────────────────────────────────────
-
-🧠 Monologue | question | Tone: curious
-
-====================================================================================================
-✨ PIPELINE COMPLETE | Session: abc123 | Total: 1250ms
-====================================================================================================
-⏱️  Stage Timings:
-   context        :   150ms ( 12.0%)
-   identity       :    10ms (  0.8%)
-   monologue      :   200ms ( 16.0%)
-   tools          :     0ms (  0.0%)
-   reflection     :    50ms (  4.0%)
-   reasoning      :   450ms ( 36.0%)  ← BOTTLENECK!
-   refinement     :   300ms ( 24.0%)
-   persona        :   140ms ( 11.2%)
-   learning       :    50ms (  4.0%)
-📤 Output: 342 characters
-====================================================================================================
-```
-
-### Verbose Mode (Maximum Debug)
-Same as detailed, plus:
-- Full raw JSON responses from LLMs (50-line boxes)
-- Complete intake data structures
-- Stack traces on errors
-
-## 🚀 How to Use
-
-### For Finding Weak Links (Your Use Case)
-```bash
-# In .env:
-LOG_DETAIL_LEVEL=detailed
-
-# Restart services:
-docker-compose restart cortex relay
-```
-
-You'll now see:
-- ✅ Which LLM backend is used
-- ✅ What prompts are sent to each LLM
-- ✅ What each LLM responds with
-- ✅ Timing breakdown showing which stage is slow
-- ✅ Context being used (RAG, intake summaries)
-- ✅ Clean, hierarchical structure
-
-### For Production
-```bash
-LOG_DETAIL_LEVEL=summary
-```
-
-### For Deep Debugging
-```bash
-LOG_DETAIL_LEVEL=verbose
-```
-
-## 🔍 Finding Performance Bottlenecks
-
-With `detailed` mode, look for:
-
-1. **Slow stages in timing breakdown:**
-   ```
-   reasoning      :  3450ms ( 76.0%)  ← THIS IS YOUR BOTTLENECK!
-   ```
-
-2. **Backend failures:**
-   ```
-   ⚠️  [LLM] PRIMARY failed | 14:23:45.234 | Connection timeout
-   ✅ [LLM] SECONDARY | Reply: Based on...  ← Fell back to secondary
-   ```
-
-3. **Loop detection:**
-   ```
-   ⚠️  DUPLICATE MESSAGE DETECTED | Session: abc123
-   🔁 LOOP DETECTED - Returning cached context
-   ```
-
-## 📁 Removed Features
-
-The following old logging features have been removed:
-
-- ❌ `VERBOSE_DEBUG` environment variable (replaced with `LOG_DETAIL_LEVEL`)
-- ❌ File logging to `/app/logs/cortex_verbose_debug.log` (use `docker logs` instead)
-- ❌ Separate verbose handlers in Python logging
-- ❌ Per-module verbose flags
-
-## ✨ New Features
-
-- ✅ Single unified logging configuration
-- ✅ Hierarchical, scannable output
-- ✅ Collapsible data sections (boxes)
-- ✅ Stage timing always shown in detailed mode
-- ✅ Performance profiling built-in
-- ✅ Loop detection and warnings
-- ✅ Clean error formatting
-
----
-
-**The logging is now clean, concise, and gives you exactly what you need to find weak links!** 🎯

LOGGING_QUICK_REF.md

@@ -1,176 +0,0 @@
-# Cortex Logging Quick Reference
-
-## 🎯 TL;DR
-
-**Finding weak links in the LLM chain?**
-```bash
-export LOG_DETAIL_LEVEL=detailed
-export VERBOSE_DEBUG=true
-```
-
-**Production use?**
-```bash
-export LOG_DETAIL_LEVEL=summary
-```
-
----
-
-## 📊 Log Levels Comparison
-
-| Level | Output Lines/Message | Use Case | Raw LLM Output? |
-|-------|---------------------|----------|-----------------|
-| **minimal** | 1-2 | Silent production | ❌ No |
-| **summary** | 5-7 | Production (DEFAULT) | ❌ No |
-| **detailed** | 30-50 | Debugging, finding bottlenecks | ✅ Parsed only |
-| **verbose** | 100+ | Deep debugging, seeing raw data | ✅ Full JSON |
-
----
-
-## 🔍 Common Debugging Tasks
-
-### See Raw LLM Outputs
-```bash
-export LOG_DETAIL_LEVEL=verbose
-```
-Look for:
-```
-╭─ RAW RESPONSE ────────────────────────────────────
-│ { "choices": [ { "message": { "content": "..." } } ] }
-╰───────────────────────────────────────────────────
-```
-
-### Find Performance Bottlenecks
-```bash
-export LOG_DETAIL_LEVEL=detailed
-```
-Look for:
-```
-⏱️  Stage Timings:
-   reasoning      :  3450ms ( 76.0%)  ← SLOW!
-```
-
-### Check Which RAG Memories Are Used
-```bash
-export LOG_DETAIL_LEVEL=detailed
-```
-Look for:
-```
-╭─ RAG RESULTS (5) ──────────────────────────────
-│ [1] 0.923 | Memory content...
-```
-
-### Detect Loops
-```bash
-export ENABLE_DUPLICATE_DETECTION=true  # (default)
-```
-Look for:
-```
-⚠️  DUPLICATE MESSAGE DETECTED
-🔁 LOOP DETECTED - Returning cached context
-```
-
-### See All Backend Failures
-```bash
-export LOG_DETAIL_LEVEL=summary  # or higher
-```
-Look for:
-```
-⚠️  [LLM] PRIMARY failed | Connection timeout
-⚠️  [LLM] SECONDARY failed | Model not found
-✅ [LLM] CLOUD | Reply: Based on...
-```
-
----
-
-## 🛠️ Environment Variables Cheat Sheet
-
-```bash
-# Verbosity Control
-LOG_DETAIL_LEVEL=detailed        # minimal | summary | detailed | verbose
-VERBOSE_DEBUG=false              # true = maximum verbosity (legacy)
-
-# Raw Data Visibility
-LOG_RAW_CONTEXT_DATA=false       # Show full intake L1-L30 dumps
-
-# Loop Protection
-ENABLE_DUPLICATE_DETECTION=true  # Detect duplicate messages
-MAX_MESSAGE_HISTORY=100          # Trim history after N messages
-SESSION_TTL_HOURS=24             # Expire sessions after N hours
-
-# Features
-NEOMEM_ENABLED=false             # Enable long-term memory
-ENABLE_AUTONOMOUS_TOOLS=true     # Enable tool invocation
-ENABLE_PROACTIVE_MONITORING=true # Enable suggestions
-```
-
----
-
-## 📋 Sample Output
-
-### Summary Mode (Default - Production)
-```
-✅ [LLM] PRIMARY | 14:23:45.123 | Reply: Based on your question...
-📊 Context | Session: abc123 | Messages: 42 | Last: 5.2min | RAG: 5 results
-🧠 Monologue | question | Tone: curious
-✨ PIPELINE COMPLETE | Session: abc123 | Total: 1250ms
-📤 Output: 342 characters
-```
-
-### Detailed Mode (Debugging)
-```
-════════════════════════════════════════════════════════════════════════════
-🚀 PIPELINE START | Session: abc123 | 14:23:45.123
-════════════════════════════════════════════════════════════════════════════
-📝 User: What is the meaning of life?
-────────────────────────────────────────────────────────────────────────────
-
-────────────────────────────────────────────────────────────────────────────
-🧠 LLM CALL | Backend: PRIMARY | 14:23:45.234
-────────────────────────────────────────────────────────────────────────────
-📝 Prompt: You are Lyra, a thoughtful AI assistant...
-💬 Reply: Based on philosophical perspectives...
-
-📊 Context | Session: abc123 | Messages: 42 | Last: 5.2min | RAG: 5 results
-  ╭─ RAG RESULTS (5) ──────────────────────────────
-  │ [1] 0.923 | Previous philosophy discussion...
-  │ [2] 0.891 | Existential note...
-  ╰────────────────────────────────────────────────
-
-════════════════════════════════════════════════════════════════════════════
-✨ PIPELINE COMPLETE | Session: abc123 | Total: 1250ms
-════════════════════════════════════════════════════════════════════════════
-⏱️  Stage Timings:
-   context        :   150ms ( 12.0%)
-   reasoning      :   450ms ( 36.0%)  ← Largest component
-   persona        :   140ms ( 11.2%)
-📤 Output: 342 characters
-════════════════════════════════════════════════════════════════════════════
-```
-
----
-
-## ⚡ Quick Troubleshooting
-
-| Symptom | Check | Fix |
-|---------|-------|-----|
-| **Logs too verbose** | Current level | Set `LOG_DETAIL_LEVEL=summary` |
-| **Can't see LLM outputs** | Current level | Set `LOG_DETAIL_LEVEL=detailed` or `verbose` |
-| **Repeating operations** | Loop warnings | Check for `🔁 LOOP DETECTED` messages |
-| **Slow responses** | Stage timings | Look for stages >1000ms in detailed mode |
-| **Missing RAG data** | NEOMEM_ENABLED | Set `NEOMEM_ENABLED=true` |
-| **Out of memory** | Message history | Lower `MAX_MESSAGE_HISTORY` |
-
----
-
-## 📁 Key Files
-
-- **[.env.logging.example](.env.logging.example)** - Full configuration guide
-- **[LOGGING_REFACTOR_SUMMARY.md](LOGGING_REFACTOR_SUMMARY.md)** - Detailed explanation
-- **[cortex/utils/logging_utils.py](cortex/utils/logging_utils.py)** - Logging utilities
-- **[cortex/context.py](cortex/context.py)** - Context + loop protection
-- **[cortex/router.py](cortex/router.py)** - Pipeline stages
-- **[core/relay/lib/llm.js](core/relay/lib/llm.js)** - LLM backend logging
-
----
-
-**Need more detail? See [LOGGING_REFACTOR_SUMMARY.md](LOGGING_REFACTOR_SUMMARY.md)**

LOGGING_REFACTOR_SUMMARY.md

@@ -1,352 +0,0 @@
-# Cortex Logging Refactor Summary
-
-## 🎯 Problem Statement
-
-The cortex chat loop had severe logging issues that made debugging impossible:
-
-1. **Massive verbosity**: 100+ log lines per chat message
-2. **Raw LLM dumps**: Full JSON responses pretty-printed on every call (1000s of lines)
-3. **Repeated data**: NeoMem results logged 71 times individually
-4. **No structure**: Scattered emoji logs with no hierarchy
-5. **Impossible to debug**: Couldn't tell if loops were happening or just verbose logging
-6. **No loop protection**: Unbounded message history growth, no session cleanup, no duplicate detection
-
-## ✅ What Was Fixed
-
-### 1. **Structured Hierarchical Logging**
-
-**Before:**
-```
-🔍 RAW LLM RESPONSE: {
-  "id": "chatcmpl-123",
-  "object": "chat.completion",
-  "created": 1234567890,
-  "model": "gpt-4",
-  "choices": [
-    {
-      "index": 0,
-      "message": {
-        "role": "assistant",
-        "content": "Here is a very long response that goes on for hundreds of lines..."
-      }
-    }
-  ],
-  "usage": {
-    "prompt_tokens": 123,
-    "completion_tokens": 456,
-    "total_tokens": 579
-  }
-}
-🧠 Trying backend: PRIMARY (http://localhost:8000)
-✅ Success via PRIMARY
-[STAGE 0] Collecting unified context...
-[STAGE 0] Context collected - 5 RAG results
-[COLLECT_CONTEXT] Intake data retrieved:
-{
-  "L1": [...],
-  "L5": [...],
-  "L10": {...},
-  "L20": {...},
-  "L30": {...}
-}
-[COLLECT_CONTEXT] NeoMem search returned 71 results
-  [1] Score: 0.923 - Memory content here...
-  [2] Score: 0.891 - More memory content...
-  [3] Score: 0.867 - Even more content...
-  ... (68 more lines)
-```
-
-**After (summary mode - DEFAULT):**
-```
-✅ [LLM] PRIMARY | 14:23:45.123 | Reply: Based on your question about...
-📊 Context | Session: abc123 | Messages: 42 | Last: 5.2min | RAG: 5 results
-🧠 Monologue | question | Tone: curious
-✨ PIPELINE COMPLETE | Session: abc123 | Total: 1250ms
-📤 Output: 342 characters
-```
-
-**After (detailed mode - for debugging):**
-```
-════════════════════════════════════════════════════════════════════════════════════════════════════
-🚀 PIPELINE START | Session: abc123 | 14:23:45.123
-════════════════════════════════════════════════════════════════════════════════════════════════════
-📝 User: What is the meaning of life?
-────────────────────────────────────────────────────────────────────────────────────────────────────
-
-────────────────────────────────────────────────────────────────────────────────────────────────────
-🧠 LLM CALL | Backend: PRIMARY | 14:23:45.234
-────────────────────────────────────────────────────────────────────────────────────────────────────
-📝 Prompt: You are Lyra, a thoughtful AI assistant...
-💬 Reply: Based on philosophical perspectives, the meaning...
-
-📊 Context | Session: abc123 | Messages: 42 | Last: 5.2min | RAG: 5 results
-────────────────────────────────────────────────────────────────────────────────────────────────────
-[CONTEXT] Session abc123 | User: What is the meaning of life?
-────────────────────────────────────────────────────────────────────────────────────────────────────
-  Mode: default | Mood: neutral | Project: None
-  Tools: RAG, WEB, WEATHER, CODEBRAIN, POKERBRAIN
-
-  ╭─ INTAKE SUMMARIES ────────────────────────────────────────────────
-  │ L1  : Last message discussed philosophy...
-  │ L5  : Recent 5 messages covered existential topics...
-  │ L10 : Past 10 messages showed curiosity pattern...
-  │ L20 : Session focused on deep questions...
-  │ L30 : Long-term trend shows philosophical interest...
-  ╰───────────────────────────────────────────────────────────────────
-
-  ╭─ RAG RESULTS (5) ──────────────────────────────────────────────
-  │ [1] 0.923 | Previous discussion about purpose and meaning...
-  │ [2] 0.891 | Note about existential philosophy...
-  │ [3] 0.867 | Memory of Viktor Frankl discussion...
-  │ [4] 0.834 | Reference to stoic philosophy...
-  │ [5] 0.801 | Buddhism and the middle path...
-  ╰───────────────────────────────────────────────────────────────────
-────────────────────────────────────────────────────────────────────────────────────────────────────
-
-════════════════════════════════════════════════════════════════════════════════════════════════════
-✨ PIPELINE COMPLETE | Session: abc123 | Total: 1250ms
-════════════════════════════════════════════════════════════════════════════════════════════════════
-⏱️  Stage Timings:
-   context        :   150ms ( 12.0%)
-   identity       :    10ms (  0.8%)
-   monologue      :   200ms ( 16.0%)
-   tools          :     0ms (  0.0%)
-   reflection     :    50ms (  4.0%)
-   reasoning      :   450ms ( 36.0%)
-   refinement     :   300ms ( 24.0%)
-   persona        :   140ms ( 11.2%)
-📤 Output: 342 characters
-════════════════════════════════════════════════════════════════════════════════════════════════════
-```
-
-### 2. **Configurable Verbosity Levels**
-
-Set via `LOG_DETAIL_LEVEL` environment variable:
-
-- **`minimal`**: Only errors and critical events
-- **`summary`**: Stage completion + errors (DEFAULT - recommended for production)
-- **`detailed`**: Include raw LLM outputs, RAG results, timing breakdowns (for debugging)
-- **`verbose`**: Everything including full JSON dumps (for deep debugging)
-
-### 3. **Raw LLM Output Visibility** ✅
-
-**You can now see raw LLM outputs clearly!**
-
-In `detailed` or `verbose` mode, LLM calls show:
-- Backend used
-- Prompt preview
-- Parsed reply
-- **Raw JSON response in collapsible format** (verbose only)
-
-```
-╭─ RAW RESPONSE ────────────────────────────────────────────────────────────────────────────
-│ {
-│   "id": "chatcmpl-123",
-│   "object": "chat.completion",
-│   "model": "gpt-4",
-│   "choices": [
-│     {
-│       "message": {
-│         "content": "Full response here..."
-│       }
-│     }
-│   ]
-│ }
-╰───────────────────────────────────────────────────────────────────────────────────────────
-```
-
-### 4. **Loop Detection & Protection** ✅
-
-**New safety features:**
-
-- **Duplicate message detection**: Prevents processing the same message twice
-- **Message history trimming**: Auto-trims to last 100 messages (configurable via `MAX_MESSAGE_HISTORY`)
-- **Session TTL**: Auto-expires inactive sessions after 24 hours (configurable via `SESSION_TTL_HOURS`)
-- **Hash-based detection**: Uses MD5 hash to detect exact duplicate messages
-
-**Example warning when loop detected:**
-```
-⚠️  DUPLICATE MESSAGE DETECTED | Session: abc123 | Message: What is the meaning of life?
-🔁 LOOP DETECTED - Returning cached context to prevent processing duplicate
-```
-
-### 5. **Performance Timing** ✅
-
-In `detailed` mode, see exactly where time is spent:
-
-```
-⏱️  Stage Timings:
-   context        :   150ms ( 12.0%)  ← Context collection
-   identity       :    10ms (  0.8%)  ← Identity loading
-   monologue      :   200ms ( 16.0%)  ← Inner monologue
-   tools          :     0ms (  0.0%)  ← Autonomous tools
-   reflection     :    50ms (  4.0%)  ← Reflection notes
-   reasoning      :   450ms ( 36.0%)  ← Main reasoning (BOTTLENECK)
-   refinement     :   300ms ( 24.0%)  ← Answer refinement
-   persona        :   140ms ( 11.2%)  ← Persona layer
-```
-
-**This helps you identify weak links in the chain!**
-
-## 📁 Files Modified
-
-### Core Changes
-
-1. **[llm.js](core/relay/lib/llm.js)**
-   - Removed massive JSON dump on line 53
-   - Added structured logging with 4 verbosity levels
-   - Shows raw responses only in verbose mode (collapsible format)
-   - Tracks failed backends and shows summary on total failure
-
-2. **[context.py](cortex/context.py)**
-   - Condensed 71-line NeoMem loop to 5-line summary
-   - Removed repeated intake data dumps
-   - Added structured hierarchical logging with boxes
-   - Added duplicate message detection
-   - Added message history trimming
-   - Added session TTL and cleanup
-
-3. **[router.py](cortex/router.py)**
-   - Replaced 15+ stage logs with unified pipeline summary
-   - Added stage timing collection
-   - Shows performance breakdown in detailed mode
-   - Clean start/end markers with total duration
-
-### New Files
-
-4. **[utils/logging_utils.py](cortex/utils/logging_utils.py)** (NEW)
-   - Reusable structured logging utilities
-   - `PipelineLogger` class for hierarchical logging
-   - Collapsible data sections
-   - Stage timing tracking
-   - Future-ready for expansion
-
-5. **[.env.logging.example](.env.logging.example)** (NEW)
-   - Complete logging configuration guide
-   - Shows example output at each verbosity level
-   - Documents all environment variables
-   - Production-ready defaults
-
-6. **[LOGGING_REFACTOR_SUMMARY.md](LOGGING_REFACTOR_SUMMARY.md)** (THIS FILE)
-
-## 🚀 How to Use
-
-### For Finding Weak Links (Your Use Case)
-
-```bash
-# Set in your .env or export:
-export LOG_DETAIL_LEVEL=detailed
-export VERBOSE_DEBUG=false  # or true for even more detail
-
-# Now run your chat - you'll see:
-# 1. Which LLM backend is used
-# 2. Raw LLM outputs (in verbose mode)
-# 3. Exact timing per stage
-# 4. Which stage is taking longest
-```
-
-### For Production
-
-```bash
-export LOG_DETAIL_LEVEL=summary
-
-# Minimal, clean logs:
-# ✅ [LLM] PRIMARY | 14:23:45.123 | Reply: Based on your question...
-# ✨ PIPELINE COMPLETE | Session: abc123 | Total: 1250ms
-```
-
-### For Deep Debugging
-
-```bash
-export LOG_DETAIL_LEVEL=verbose
-export LOG_RAW_CONTEXT_DATA=true
-
-# Shows EVERYTHING including full JSON dumps
-```
-
-## 🔍 Finding Weak Links - Quick Guide
-
-**Problem: "Which LLM stage is failing or producing bad output?"**
-
-1. Set `LOG_DETAIL_LEVEL=detailed`
-2. Run a test conversation
-3. Look for timing anomalies:
-   ```
-   reasoning      :  3450ms ( 76.0%)  ← BOTTLENECK!
-   ```
-4. Look for errors:
-   ```
-   ⚠️  Reflection failed: Connection timeout
-   ```
-5. Check raw LLM outputs (set `VERBOSE_DEBUG=true`):
-   ```
-   ╭─ RAW RESPONSE ────────────────────────────────────
-   │ {
-   │   "choices": [
-   │     { "message": { "content": "..." } }
-   │   ]
-   │ }
-   ╰───────────────────────────────────────────────────
-   ```
-
-**Problem: "Is the loop repeating operations?"**
-
-1. Enable duplicate detection (on by default)
-2. Look for loop warnings:
-   ```
-   ⚠️  DUPLICATE MESSAGE DETECTED | Session: abc123
-   🔁 LOOP DETECTED - Returning cached context
-   ```
-3. Check stage timings - repeated stages will show up as duplicates
-
-**Problem: "Which RAG memories are being used?"**
-
-1. Set `LOG_DETAIL_LEVEL=detailed`
-2. Look for RAG results box:
-   ```
-   ╭─ RAG RESULTS (5) ──────────────────────────────
-   │ [1] 0.923 | Previous discussion about X...
-   │ [2] 0.891 | Note about Y...
-   ╰────────────────────────────────────────────────
-   ```
-
-## 📊 Environment Variables Reference
-
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `LOG_DETAIL_LEVEL` | `summary` | Verbosity: minimal/summary/detailed/verbose |
-| `VERBOSE_DEBUG` | `false` | Legacy flag for maximum verbosity |
-| `LOG_RAW_CONTEXT_DATA` | `false` | Show full intake data dumps |
-| `ENABLE_DUPLICATE_DETECTION` | `true` | Detect and prevent duplicate messages |
-| `MAX_MESSAGE_HISTORY` | `100` | Max messages to keep per session |
-| `SESSION_TTL_HOURS` | `24` | Auto-expire sessions after N hours |
-
-## 🎉 Results
-
-**Before:** 1000+ lines of logs per chat message, unreadable, couldn't identify issues
-
-**After (summary mode):** 5 lines of structured logs, clear and actionable
-
-**After (detailed mode):** ~50 lines with full visibility into each stage, timing, and raw outputs
-
-**Loop protection:** Automatic detection and prevention of duplicate processing
-
-**You can now:**
-✅ See raw LLM outputs clearly (in detailed/verbose mode)
-✅ Identify performance bottlenecks (stage timings)
-✅ Detect loops and duplicates (automatic)
-✅ Find failing stages (error markers)
-✅ Scan logs quickly (hierarchical structure)
-✅ Debug production issues (adjustable verbosity)
-
-## 🔧 Next Steps (Optional Improvements)
-
-1. **Structured JSON logging**: Output as JSON for log aggregation tools
-2. **Log rotation**: Implement file rotation for verbose logs
-3. **Metrics export**: Export stage timings to Prometheus/Grafana
-4. **Error categorization**: Tag errors by type (network, timeout, parsing, etc.)
-5. **Performance alerts**: Auto-alert when stages exceed thresholds
-
----
-
-**Happy debugging! You can now see what's actually happening in the cortex loop.** 🎯

QUICKSTART.md

@@ -0,0 +1,124 @@
+# Lyra Quickstart
+
+## Architecture
+
+Lyra is now a **unified container** running:
+- **Relay** (Node.js on port 7078) - User-facing API with OpenAI-compatible endpoints
+- **Cortex** (Python on port 7081) - Brain with Intake summarization pipeline
+- **Intake** - Multi-level summarization (L1-L30) that sends to Nebula
+
+## Running Lyra
+
+### 1. Start the system
+```bash
+docker-compose up -d
+```
+
+### 2. Check logs
+```bash
+# All services
+docker-compose logs -f lyra
+
+# Just startup
+docker-compose logs lyra
+```
+
+### 3. Verify it's running
+```bash
+# Check Relay
+curl http://localhost:7078/_health
+
+# Check Cortex
+curl http://localhost:7081/_health
+
+# View UI
+open http://localhost:8081
+```
+
+## Making Changes
+
+### Restart after code changes
+```bash
+docker-compose restart lyra
+```
+
+### Rebuild after dependency changes
+```bash
+docker-compose up -d --build lyra
+```
+
+## Architecture Details
+
+```
+┌─────────────────────────────────────┐
+│   Unified Container (lyra)          │
+│                                      │
+│  ┌──────────────┐  ┌─────────────┐  │
+│  │ Relay :7078  │  │Cortex :7081 │  │
+│  │  (Node.js)   │─→│  (Python)   │  │
+│  └──────────────┘  └─────────────┘  │
+│                         │            │
+│                         ↓            │
+│                    ┌─────────┐       │
+│                    │ Intake  │       │
+│                    │Summarize│       │
+│                    └─────────┘       │
+│                         │            │
+└─────────────────────────┼────────────┘
+                          ↓
+                    ┌──────────┐
+                    │  Nebula  │  (external, to be built)
+                    │  (vector │
+                    │ storage) │
+                    └──────────┘
+```
+
+## Endpoints
+
+### Relay (Port 7078)
+- `POST /chat` - Lyra-native chat endpoint
+- `POST /v1/chat/completions` - OpenAI-compatible endpoint
+- `GET /sessions` - List sessions
+- `GET /_health` - Health check
+
+### Cortex (Port 7081)
+- `POST /reason` - Full reasoning pipeline
+- `POST /simple` - Simple chat mode
+- `POST /ingest` - Internal intake endpoint
+- `GET /_health` - Health check
+
+## Environment Variables
+
+Key variables in `.env`:
+```bash
+# LLM Configuration
+PRIMARY_LLM_PROVIDER=anthropic
+ANTHROPIC_API_KEY=sk-...
+
+# Nebula (when available)
+NEBULA_API=http://nebula:7090
+NEBULA_KEY=your-key
+
+# Intake Settings
+INTAKE_LLM=PRIMARY
+SUMMARY_MAX_TOKENS=200
+SUMMARY_TEMPERATURE=0.3
+```
+
+## Data Persistence
+
+Until Nebula is running, summaries are saved to:
+```
+.nebula_fallback/
+  └── {session_id}/
+      ├── L10_20260223_203045.json
+      ├── L20_20260223_204512.json
+      └── L30_20260223_210030.json
+```
+
+Sessions are saved to:
+```
+core/relay/sessions/
+  ├── {session_id}.json
+  └── {session_id}.meta.json
+```

THINKING_STREAM.md

@@ -1,163 +0,0 @@
-# "Show Your Work" - Thinking Stream Feature
-
-Real-time Server-Sent Events (SSE) stream that broadcasts the internal thinking process during tool calling operations.
-
-## What It Does
-
-When Lyra uses tools to answer a question, you can now watch her "think" in real-time through a parallel stream:
-
-- 🤔 **Thinking** - When she's planning what to do
-- 🔧 **Tool Calls** - When she decides to use a tool
-- 📊 **Tool Results** - The results from tool execution
-- ✅ **Done** - When she has the final answer
-- ❌ **Errors** - If something goes wrong
-
-## How To Use
-
-### 1. Open the SSE Stream
-
-Connect to the thinking stream for a session:
-
-```bash
-curl -N http://localhost:7081/stream/thinking/{session_id}
-```
-
-The stream will send Server-Sent Events in this format:
-
-```
-data: {"type": "thinking", "data": {"message": "🤔 Thinking... (iteration 1/5)"}}
-
-data: {"type": "tool_call", "data": {"tool": "execute_code", "args": {...}, "message": "🔧 Using tool: execute_code"}}
-
-data: {"type": "tool_result", "data": {"tool": "execute_code", "result": {...}, "message": "📊 Result: ..."}}
-
-data: {"type": "done", "data": {"message": "✅ Complete!", "final_answer": "The result is..."}}
-```
-
-### 2. Send a Request
-
-In parallel, send a request to `/simple` with the same `session_id`:
-
-```bash
-curl -X POST http://localhost:7081/simple \
-  -H "Content-Type: application/json" \
-  -d '{
-    "session_id": "your-session-id",
-    "user_prompt": "Calculate 50/2 using Python",
-    "backend": "SECONDARY"
-  }'
-```
-
-### 3. Watch the Stream
-
-As the request processes, you'll see real-time events showing:
-- Each thinking iteration
-- Every tool call being made
-- The results from each tool
-- The final answer
-
-## Event Types
-
-| Event Type | Description | Data Fields |
-|-----------|-------------|-------------|
-| `connected` | Initial connection | `session_id` |
-| `thinking` | LLM is processing | `message` |
-| `tool_call` | Tool is being invoked | `tool`, `args`, `message` |
-| `tool_result` | Tool execution completed | `tool`, `result`, `message` |
-| `done` | Process complete | `message`, `final_answer` |
-| `error` | Something went wrong | `message` |
-
-## Demo Page
-
-A demo HTML page is included at [test_thinking_stream.html](../test_thinking_stream.html):
-
-```bash
-# Serve the demo page
-python3 -m http.server 8000
-```
-
-Then open http://localhost:8000/test_thinking_stream.html in your browser.
-
-The demo shows:
-- **Left panel**: Chat interface
-- **Right panel**: Real-time thinking stream
-- **Mobile**: Swipe between panels
-
-## Architecture
-
-### Components
-
-1. **ToolStreamManager** (`autonomy/tools/stream_events.py`)
-   - Manages SSE subscriptions per session
-   - Broadcasts events to all connected clients
-   - Handles automatic cleanup
-
-2. **FunctionCaller** (`autonomy/tools/function_caller.py`)
-   - Enhanced with event emission at each step
-   - Checks for active subscribers before emitting
-   - Passes `session_id` through the call chain
-
-3. **SSE Endpoint** (`/stream/thinking/{session_id}`)
-   - FastAPI streaming response
-   - 30-second keepalive for connection maintenance
-   - Automatic reconnection on client side
-
-### Event Flow
-
-```
-Client                 SSE Endpoint           FunctionCaller          Tools
-  |                         |                         |                  |
-  |--- Connect SSE -------->|                         |                  |
-  |<-- connected ----------|                          |                  |
-  |                         |                         |                  |
-  |--- POST /simple --------|                         |                  |
-  |                         |                         |                  |
-  |                         |<-- emit("thinking") ---|                  |
-  |<-- thinking ------------|                         |                  |
-  |                         |                         |                  |
-  |                         |<-- emit("tool_call") ---|                  |
-  |<-- tool_call -----------|                         |                  |
-  |                         |                         |-- execute ------>|
-  |                         |                         |<-- result -------|
-  |                         |<-- emit("tool_result")--|                  |
-  |<-- tool_result ---------|                         |                  |
-  |                         |                         |                  |
-  |                         |<-- emit("done") --------|                  |
-  |<-- done ---------------|                         |                  |
-  |                         |                         |                  |
-```
-
-## Configuration
-
-No additional configuration needed! The feature works automatically when:
-1. `STANDARD_MODE_ENABLE_TOOLS=true` (already set)
-2. A client connects to the SSE stream BEFORE sending the request
-
-## Example Output
-
-```
-🟢 Connected to thinking stream
-✓ Connected (Session: thinking-demo-1735177234567)
-🤔 Thinking... (iteration 1/5)
-🔧 Using tool: execute_code
-📊 Result: {'stdout': '12.0\n', 'stderr': '', 'exit_code': 0, 'execution_time': 0.04}
-🤔 Thinking... (iteration 2/5)
-✅ Complete!
-```
-
-## Use Cases
-
-- **Debugging**: See exactly what tools are being called and why
-- **Transparency**: Show users what the AI is doing behind the scenes
-- **Education**: Learn how the system breaks down complex tasks
-- **UI Enhancement**: Create engaging "thinking" animations
-- **Mobile App**: Separate tab for "Show Your Work" view
-
-## Future Enhancements
-
-Potential additions:
-- Token usage per iteration
-- Estimated time remaining
-- Tool execution duration
-- Intermediate reasoning steps
-- Visual progress indicators

UI_THINKING_STREAM.md

@@ -1,109 +0,0 @@
-# Thinking Stream UI Integration
-
-## What Was Added
-
-Added a "🧠 Show Work" button to the main chat interface that opens a dedicated thinking stream window.
-
-## Changes Made
-
-### 1. Main Chat Interface ([core/ui/index.html](core/ui/index.html))
-
-Added button to session selector:
-```html
-<button id="thinkingStreamBtn" title="Show thinking stream in new window">🧠 Show Work</button>
-```
-
-Added event listener to open stream window:
-```javascript
-document.getElementById("thinkingStreamBtn").addEventListener("click", () => {
-  const streamUrl = `/thinking-stream.html?session=${currentSession}`;
-  const windowFeatures = "width=600,height=800,menubar=no,toolbar=no,location=no,status=no";
-  window.open(streamUrl, `thinking_${currentSession}`, windowFeatures);
-});
-```
-
-### 2. Thinking Stream Window ([core/ui/thinking-stream.html](core/ui/thinking-stream.html))
-
-New dedicated page for the thinking stream:
-- **Header**: Shows connection status with live indicator
-- **Events Area**: Scrollable list of thinking events
-- **Footer**: Clear button and session info
-
-Features:
-- Auto-reconnecting SSE connection
-- Color-coded event types
-- Slide-in animations for new events
-- Automatic scrolling to latest event
-- Session ID from URL parameter
-
-### 3. Styling ([core/ui/style.css](core/ui/style.css))
-
-Added purple/violet theme for the thinking button:
-```css
-#thinkingStreamBtn {
-  background: rgba(138, 43, 226, 0.2);
-  border-color: #8a2be2;
-}
-```
-
-## How To Use
-
-1. **Open Chat Interface**
-   - Navigate to http://localhost:7078 (relay)
-   - Select or create a session
-
-2. **Open Thinking Stream**
-   - Click the "🧠 Show Work" button
-   - A new window opens showing the thinking stream
-
-3. **Send a Message**
-   - Type a message that requires tools (e.g., "Calculate 50/2 in Python")
-   - Watch the thinking stream window for real-time updates
-
-4. **Observe Events**
-   - 🤔 Thinking iterations
-   - 🔧 Tool calls
-   - 📊 Tool results
-   - ✅ Completion
-
-## Event Types & Colors
-
-| Event | Icon | Color | Description |
-|-------|------|-------|-------------|
-| Connected | ✓ | Green | Stream established |
-| Thinking | 🤔 | Light Green | LLM processing |
-| Tool Call | 🔧 | Orange | Tool invocation |
-| Tool Result | 📊 | Blue | Tool output |
-| Done | ✅ | Purple | Task complete |
-| Error | ❌ | Red | Something failed |
-
-## Architecture
-
-```
-User clicks "Show Work"
-        ↓
-Opens thinking-stream.html?session=xxx
-        ↓
-Connects to SSE: /stream/thinking/{session}
-        ↓
-User sends message in main chat
-        ↓
-FunctionCaller emits events
-        ↓
-Events appear in thinking stream window
-```
-
-## Mobile Support
-
-The thinking stream window is responsive:
-- Desktop: Side-by-side windows
-- Mobile: Use browser's tab switcher to swap between chat and thinking stream
-
-## Future Enhancements
-
-Potential improvements:
-- **Embedded panel**: Option to show thinking stream in a split panel within main UI
-- **Event filtering**: Toggle event types on/off
-- **Export**: Download thinking trace as JSON
-- **Replay**: Replay past thinking sessions
-- **Statistics**: Show timing, token usage per step

core/persona-sidecar/Dockerfile

@@ -1,14 +0,0 @@
-FROM node:18-alpine
-
-WORKDIR /app
-
-# install deps
-COPY package.json ./package.json
-RUN npm install --production
-
-# copy code + config
-COPY persona-server.js ./persona-server.js
-COPY personas.json ./personas.json
-
-EXPOSE 7080
-CMD ["node", "persona-server.js"]

core/persona-sidecar/package.json

@@ -1,8 +0,0 @@
-{
-  "name": "persona-sidecar",
-  "version": "0.1.0",
-  "type": "module",
-  "dependencies": {
-    "express": "^4.19.2"
-  }
-}

core/persona-sidecar/persona-server.js

@@ -1,78 +0,0 @@
-// persona-server.js — Persona Sidecar v0.1.0 (Docker Lyra)
-// Node 18+, Express REST
-
-import express from "express";
-import fs from "fs";
-
-const app = express();
-app.use(express.json());
-
-const PORT = process.env.PORT || 7080;
-const CONFIG_FILE = process.env.PERSONAS_FILE || "./personas.json";
-
-// allow JSON with // and /* */ comments
-function parseJsonWithComments(raw) {
-  return JSON.parse(
-    raw
-      .replace(/\/\*[\s\S]*?\*\//g, "")   // block comments
-      .replace(/^\s*\/\/.*$/gm, "")       // line comments
-  );
-}
-
-function loadConfig() {
-  const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
-  return parseJsonWithComments(raw);
-}
-
-function saveConfig(cfg) {
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2));
-}
-
-// GET /persona → active persona JSON
-app.get("/persona", (_req, res) => {
-  try {
-    const cfg = loadConfig();
-    const active = cfg.active;
-    const persona = cfg.personas?.[active];
-    if (!persona) return res.status(404).json({ error: "Active persona not found" });
-    res.json({ active, persona });
-  } catch (err) {
-    res.status(500).json({ error: String(err.message || err) });
-  }
-});
-
-// GET /personas → all personas
-app.get("/personas", (_req, res) => {
-  try {
-    const cfg = loadConfig();
-    res.json(cfg.personas || {});
-  } catch (err) {
-    res.status(500).json({ error: String(err.message || err) });
-  }
-});
-
-// POST /persona/select { name }
-app.post("/persona/select", (req, res) => {
-  try {
-    const { name } = req.body || {};
-    if (!name) return res.status(400).json({ error: "Missing 'name'" });
-
-    const cfg = loadConfig();
-    if (!cfg.personas || !cfg.personas[name]) {
-      return res.status(404).json({ error: `Persona '${name}' not found` });
-    }
-    cfg.active = name;
-    saveConfig(cfg);
-    res.json({ ok: true, active: name });
-  } catch (err) {
-    res.status(500).json({ error: String(err.message || err) });
-  }
-});
-
-// health + fallback
-app.get("/_health", (_req, res) => res.json({ ok: true, time: new Date().toISOString() }));
-app.use((_req, res) => res.status(404).json({ error: "no such route" }));
-
-app.listen(PORT, () => {
-  console.log(`Persona Sidecar listening on :${PORT}`);
-});

core/persona-sidecar/personas.json

@@ -1,17 +0,0 @@
-{
-  // v0.1.0 default active persona
-  "active": "Lyra",
-
-  // Personas available to the service
-  "personas": {
-    "Lyra": {
-      "name": "Lyra",
-      "style": "warm, slyly supportive, collaborative confidante",
-      "protocols": ["Project logs", "Confidence Bank", "Scar Notes"]
-    }
-  }
-
-  // Placeholders for later (commented out for now)
-  // "Doyle": { "name": "Doyle", "style": "gritty poker grinder", "protocols": [] },
-  // "Mr GPT": { "name": "Mr GPT", "style": "direct, tactical mentor", "protocols": [] }
-}

core/relay/server.js

@@ -21,9 +21,9 @@ app.use(express.json());
 
 const PORT = Number(process.env.PORT || 7078);
 
-// Cortex endpoints
+// Cortex endpoints (localhost since they're in the same container now)
-const CORTEX_REASON = process.env.CORTEX_REASON_URL || "http://cortex:7081/reason";
+const CORTEX_REASON = process.env.CORTEX_REASON_URL || "http://localhost:7081/reason";
-const CORTEX_SIMPLE = process.env.CORTEX_SIMPLE_URL || "http://cortex:7081/simple";
+const CORTEX_SIMPLE = process.env.CORTEX_SIMPLE_URL || "http://localhost:7081/simple";
 
 // -----------------------------------------------------
 // Helper request wrapper

cortex/autonomy/Assembly-spec.md

@@ -1,249 +0,0 @@
-# 📐 Project Lyra — Cognitive Assembly Spec
-**Version:** 0.6.1  
-**Status:** Canonical reference  
-**Purpose:** Define clear separation of Self, Thought, Reasoning, and Speech
-
----
-
-## 1. High-Level Overview
-
-Lyra is composed of **four distinct cognitive layers**, plus I/O.
-
-Each layer has:
-- a **responsibility**
-- a **scope**
-- clear **inputs / outputs**
-- explicit **authority boundaries**
-
-No layer is allowed to “do everything.”
-
----
-
-## 2. Layer Definitions
-
-### 2.1 Autonomy / Self (NON-LLM)
-
-**What it is**
-- Persistent identity
-- Long-term state
-- Mood, preferences, values
-- Continuity across time
-
-**What it is NOT**
-- Not a reasoning engine
-- Not a planner
-- Not a speaker
-- Not creative
-
-**Implementation**
-- Data + light logic
-- JSON / Python objects
-- No LLM calls
-
-**Lives at**
-```
-project-lyra/autonomy/self/
-```
-
-**Inputs**
-- Events (user message received, response sent)
-- Time / idle ticks (later)
-
-**Outputs**
-- Self state snapshot
-- Flags / preferences (e.g. verbosity, tone bias)
-
----
-
-### 2.2 Inner Monologue (LLM, PRIVATE)
-
-**What it is**
-- Internal language-based thought
-- Reflection
-- Intent formation
-- “What do I think about this?”
-
-**What it is NOT**
-- Not final reasoning
-- Not execution
-- Not user-facing
-
-**Model**
-- MythoMax
-
-**Lives at**
-```
-project-lyra/autonomy/monologue/
-```
-
-**Inputs**
-- User message
-- Self state snapshot
-- Recent context summary
-
-**Outputs**
-- Intent
-- Tone guidance
-- Depth guidance
-- “Consult executive?” flag
-
-**Example Output**
-```json
-{
-  "intent": "technical_exploration",
-  "tone": "focused",
-  "depth": "deep",
-  "consult_executive": true
-}
-```
-
----
-
-### 2.3 Cortex (Reasoning & Execution)
-
-**What it is**
-- Thinking pipeline
-- Planning
-- Tool selection
-- Task execution
-- Draft generation
-
-**What it is NOT**
-- Not identity
-- Not personality
-- Not persistent self
-
-**Models**
-- DeepSeek-R1 → Executive / Planner
-- GPT-4o-mini → Executor / Drafter
-
-**Lives at**
-```
-project-lyra/cortex/
-```
-
-**Inputs**
-- User message
-- Inner Monologue output
-- Memory / RAG / tools
-
-**Outputs**
-- Draft response (content only)
-- Metadata (sources, confidence, etc.)
-
----
-
-### 2.4 Persona / Speech (LLM, USER-FACING)
-
-**What it is**
-- Voice
-- Style
-- Expression
-- Social behavior
-
-**What it is NOT**
-- Not planning
-- Not deep reasoning
-- Not decision-making
-
-**Model**
-- MythoMax
-
-**Lives at**
-```
-project-lyra/core/persona/
-```
-
-**Inputs**
-- Draft response (from Cortex)
-- Tone + intent (from Inner Monologue)
-- Persona configuration
-
-**Outputs**
-- Final user-visible text
-
----
-
-## 3. Message Flow (Authoritative)
-
-### 3.1 Standard Message Path
-
-```
-User
-  ↓
-UI
-  ↓
-Relay
-  ↓
-Cortex
-  ↓
-Autonomy / Self (state snapshot)
-  ↓
-Inner Monologue (MythoMax)
-  ↓
-[ consult_executive? ]
-    ├─ Yes → DeepSeek-R1 (plan)
-    └─ No  → skip
-  ↓
-GPT-4o-mini (execute & draft)
-  ↓
-Persona (MythoMax)
-  ↓
-Relay
-  ↓
-UI
-  ↓
-User
-```
-
-### 3.2 Fast Path (No Thinking)
-
-```
-User → UI → Relay → Persona → Relay → UI
-```
-
----
-
-## 4. Authority Rules (Non-Negotiable)
-
-- Self never calls an LLM
-- Inner Monologue never speaks to the user
-- Cortex never applies personality
-- Persona never reasons or plans
-- DeepSeek never writes final answers
-- MythoMax never plans execution
-
----
-
-## 5. Folder Mapping
-
-```
-project-lyra/
-├── autonomy/
-│   ├── self/
-│   ├── monologue/
-│   └── executive/
-├── cortex/
-├── core/
-│   └── persona/
-├── relay/
-└── ui/
-```
-
----
-
-## 6. Current Status
-
-- UI ✔
-- Relay ✔
-- Cortex ✔
-- Persona ✔
-- Autonomy ✔
-- Inner Monologue ⚠ partially wired
-- Executive gating ⚠ planned
-
----
-
-## 7. Next Decision
-
-Decide whether **Inner Monologue runs every message** or **only when triggered**.

cortex/autonomy/__init__.py

@@ -1 +0,0 @@
-# Autonomy module for Lyra

cortex/autonomy/actions/__init__.py

@@ -1 +0,0 @@
-"""Autonomous action execution system."""

cortex/autonomy/actions/autonomous_actions.py

@@ -1,480 +0,0 @@
-"""
-Autonomous Action Manager - executes safe, self-initiated actions.
-"""
-
-import logging
-import json
-from typing import Dict, List, Any, Optional
-from datetime import datetime
-
-logger = logging.getLogger(__name__)
-
-
-class AutonomousActionManager:
-    """
-    Manages safe autonomous actions that Lyra can take without explicit user prompting.
-
-    Whitelist of allowed actions:
-    - create_memory: Store information in NeoMem
-    - update_goal: Modify goal status
-    - schedule_reminder: Create future reminder
-    - summarize_session: Generate conversation summary
-    - learn_topic: Add topic to learning queue
-    - update_focus: Change current focus area
-    """
-
-    def __init__(self):
-        """Initialize action manager with whitelisted actions."""
-        self.allowed_actions = {
-            "create_memory": self._create_memory,
-            "update_goal": self._update_goal,
-            "schedule_reminder": self._schedule_reminder,
-            "summarize_session": self._summarize_session,
-            "learn_topic": self._learn_topic,
-            "update_focus": self._update_focus
-        }
-
-        self.action_log = []  # Track all actions for audit
-
-    async def execute_action(
-        self,
-        action_type: str,
-        parameters: Dict[str, Any],
-        context: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Execute a single autonomous action.
-
-        Args:
-            action_type: Type of action (must be in whitelist)
-            parameters: Action-specific parameters
-            context: Current context state
-
-        Returns:
-            {
-                "success": bool,
-                "action": action_type,
-                "result": action_result,
-                "timestamp": ISO timestamp,
-                "error": optional error message
-            }
-        """
-        # Safety check: action must be whitelisted
-        if action_type not in self.allowed_actions:
-            logger.error(f"[ACTIONS] Attempted to execute non-whitelisted action: {action_type}")
-            return {
-                "success": False,
-                "action": action_type,
-                "error": f"Action '{action_type}' not in whitelist",
-                "timestamp": datetime.utcnow().isoformat()
-            }
-
-        try:
-            logger.info(f"[ACTIONS] Executing autonomous action: {action_type}")
-
-            # Execute the action
-            action_func = self.allowed_actions[action_type]
-            result = await action_func(parameters, context)
-
-            # Log successful action
-            action_record = {
-                "success": True,
-                "action": action_type,
-                "result": result,
-                "timestamp": datetime.utcnow().isoformat(),
-                "parameters": parameters
-            }
-
-            self.action_log.append(action_record)
-            logger.info(f"[ACTIONS] Action {action_type} completed successfully")
-
-            return action_record
-
-        except Exception as e:
-            logger.error(f"[ACTIONS] Action {action_type} failed: {e}")
-
-            error_record = {
-                "success": False,
-                "action": action_type,
-                "error": str(e),
-                "timestamp": datetime.utcnow().isoformat(),
-                "parameters": parameters
-            }
-
-            self.action_log.append(error_record)
-            return error_record
-
-    async def execute_batch(
-        self,
-        actions: List[Dict[str, Any]],
-        context: Dict[str, Any]
-    ) -> List[Dict[str, Any]]:
-        """
-        Execute multiple actions sequentially.
-
-        Args:
-            actions: List of {"action": str, "parameters": dict}
-            context: Current context state
-
-        Returns:
-            List of action results
-        """
-        results = []
-
-        for action_spec in actions:
-            action_type = action_spec.get("action")
-            parameters = action_spec.get("parameters", {})
-
-            result = await self.execute_action(action_type, parameters, context)
-            results.append(result)
-
-            # Stop on first failure if critical
-            if not result["success"] and action_spec.get("critical", False):
-                logger.warning(f"[ACTIONS] Critical action {action_type} failed, stopping batch")
-                break
-
-        return results
-
-    # ========================================
-    # Whitelisted Action Implementations
-    # ========================================
-
-    async def _create_memory(
-        self,
-        parameters: Dict[str, Any],
-        context: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Create a memory entry in NeoMem.
-
-        Parameters:
-            - text: Memory content (required)
-            - tags: Optional tags for memory
-            - importance: 0.0-1.0 importance score
-        """
-        text = parameters.get("text")
-        if not text:
-            raise ValueError("Memory text required")
-
-        tags = parameters.get("tags", [])
-        importance = parameters.get("importance", 0.5)
-        session_id = context.get("session_id", "autonomous")
-
-        # Import NeoMem client
-        try:
-            from memory.neomem_client import store_memory
-
-            result = await store_memory(
-                text=text,
-                session_id=session_id,
-                tags=tags,
-                importance=importance
-            )
-
-            return {
-                "memory_id": result.get("id"),
-                "text": text[:50] + "..." if len(text) > 50 else text
-            }
-
-        except ImportError:
-            logger.warning("[ACTIONS] NeoMem client not available, simulating memory storage")
-            return {
-                "memory_id": "simulated",
-                "text": text[:50] + "..." if len(text) > 50 else text,
-                "note": "NeoMem not available, memory not persisted"
-            }
-
-    async def _update_goal(
-        self,
-        parameters: Dict[str, Any],
-        context: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Update goal status in self-state.
-
-        Parameters:
-            - goal_id: Goal identifier (required)
-            - status: New status (pending/in_progress/completed)
-            - progress: Optional progress note
-        """
-        goal_id = parameters.get("goal_id")
-        if not goal_id:
-            raise ValueError("goal_id required")
-
-        status = parameters.get("status", "in_progress")
-        progress = parameters.get("progress")
-
-        # Import self-state manager
-        from autonomy.self.state import get_self_state_instance
-
-        state = get_self_state_instance()
-        active_goals = state._state.get("active_goals", [])
-
-        # Find and update goal
-        updated = False
-        for goal in active_goals:
-            if isinstance(goal, dict) and goal.get("id") == goal_id:
-                goal["status"] = status
-                if progress:
-                    goal["progress"] = progress
-                goal["updated_at"] = datetime.utcnow().isoformat()
-                updated = True
-                break
-
-        if updated:
-            state._save_state()
-            return {
-                "goal_id": goal_id,
-                "status": status,
-                "updated": True
-            }
-        else:
-            return {
-                "goal_id": goal_id,
-                "updated": False,
-                "note": "Goal not found"
-            }
-
-    async def _schedule_reminder(
-        self,
-        parameters: Dict[str, Any],
-        context: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Schedule a future reminder.
-
-        Parameters:
-            - message: Reminder text (required)
-            - delay_minutes: Minutes until reminder
-            - priority: 0.0-1.0 priority score
-        """
-        message = parameters.get("message")
-        if not message:
-            raise ValueError("Reminder message required")
-
-        delay_minutes = parameters.get("delay_minutes", 60)
-        priority = parameters.get("priority", 0.5)
-
-        # For now, store in self-state's learning queue
-        # In future: integrate with scheduler/cron system
-        from autonomy.self.state import get_self_state_instance
-
-        state = get_self_state_instance()
-
-        reminder = {
-            "type": "reminder",
-            "message": message,
-            "scheduled_at": datetime.utcnow().isoformat(),
-            "trigger_at_minutes": delay_minutes,
-            "priority": priority
-        }
-
-        # Add to learning queue as placeholder
-        state._state.setdefault("reminders", []).append(reminder)
-        state._save_state(state._state)  # Pass state dict as argument
-
-        logger.info(f"[ACTIONS] Reminder scheduled: {message} (in {delay_minutes}min)")
-
-        return {
-            "message": message,
-            "delay_minutes": delay_minutes,
-            "note": "Reminder stored in self-state (scheduler integration pending)"
-        }
-
-    async def _summarize_session(
-        self,
-        parameters: Dict[str, Any],
-        context: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Generate a summary of current session.
-
-        Parameters:
-            - max_length: Max summary length in words
-            - focus_topics: Optional list of topics to emphasize
-        """
-        max_length = parameters.get("max_length", 200)
-        session_id = context.get("session_id", "unknown")
-
-        # Import summarizer (from deferred_summary or create simple one)
-        try:
-            from utils.deferred_summary import summarize_conversation
-
-            summary = await summarize_conversation(
-                session_id=session_id,
-                max_words=max_length
-            )
-
-            return {
-                "summary": summary,
-                "word_count": len(summary.split())
-            }
-
-        except ImportError:
-            # Fallback: simple summary
-            message_count = context.get("message_count", 0)
-            focus = context.get("monologue", {}).get("intent", "general")
-
-            summary = f"Session {session_id}: {message_count} messages exchanged, focused on {focus}."
-
-            return {
-                "summary": summary,
-                "word_count": len(summary.split()),
-                "note": "Simple summary (full summarizer not available)"
-            }
-
-    async def _learn_topic(
-        self,
-        parameters: Dict[str, Any],
-        context: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Add topic to learning queue.
-
-        Parameters:
-            - topic: Topic name (required)
-            - reason: Why this topic
-            - priority: 0.0-1.0 priority score
-        """
-        topic = parameters.get("topic")
-        if not topic:
-            raise ValueError("Topic required")
-
-        reason = parameters.get("reason", "autonomous learning")
-        priority = parameters.get("priority", 0.5)
-
-        # Import self-state manager
-        from autonomy.self.state import get_self_state_instance
-
-        state = get_self_state_instance()
-        state.add_learning_goal(topic)  # Only pass topic parameter
-
-        logger.info(f"[ACTIONS] Added to learning queue: {topic} (reason: {reason})")
-
-        return {
-            "topic": topic,
-            "reason": reason,
-            "queue_position": len(state._state.get("learning_queue", []))
-        }
-
-    async def _update_focus(
-        self,
-        parameters: Dict[str, Any],
-        context: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Update current focus area.
-
-        Parameters:
-            - focus: New focus area (required)
-            - reason: Why this focus
-        """
-        focus = parameters.get("focus")
-        if not focus:
-            raise ValueError("Focus required")
-
-        reason = parameters.get("reason", "autonomous update")
-
-        # Import self-state manager
-        from autonomy.self.state import get_self_state_instance
-
-        state = get_self_state_instance()
-        old_focus = state._state.get("focus", "none")
-
-        state._state["focus"] = focus
-        state._state["focus_updated_at"] = datetime.utcnow().isoformat()
-        state._state["focus_reason"] = reason
-        state._save_state(state._state)  # Pass state dict as argument
-
-        logger.info(f"[ACTIONS] Focus updated: {old_focus} -> {focus}")
-
-        return {
-            "old_focus": old_focus,
-            "new_focus": focus,
-            "reason": reason
-        }
-
-    # ========================================
-    # Utility Methods
-    # ========================================
-
-    def get_allowed_actions(self) -> List[str]:
-        """Get list of all allowed action types."""
-        return list(self.allowed_actions.keys())
-
-    def get_action_log(self, limit: int = 50) -> List[Dict[str, Any]]:
-        """
-        Get recent action log.
-
-        Args:
-            limit: Max number of entries to return
-
-        Returns:
-            List of action records
-        """
-        return self.action_log[-limit:]
-
-    def clear_action_log(self) -> None:
-        """Clear action log."""
-        self.action_log = []
-        logger.info("[ACTIONS] Action log cleared")
-
-    def validate_action(self, action_type: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Validate an action without executing it.
-
-        Args:
-            action_type: Type of action
-            parameters: Action parameters
-
-        Returns:
-            {
-                "valid": bool,
-                "action": action_type,
-                "errors": [error messages] or []
-            }
-        """
-        errors = []
-
-        # Check whitelist
-        if action_type not in self.allowed_actions:
-            errors.append(f"Action '{action_type}' not in whitelist")
-
-        # Check required parameters (basic validation)
-        if action_type == "create_memory" and not parameters.get("text"):
-            errors.append("Memory 'text' parameter required")
-
-        if action_type == "update_goal" and not parameters.get("goal_id"):
-            errors.append("Goal 'goal_id' parameter required")
-
-        if action_type == "schedule_reminder" and not parameters.get("message"):
-            errors.append("Reminder 'message' parameter required")
-
-        if action_type == "learn_topic" and not parameters.get("topic"):
-            errors.append("Learning 'topic' parameter required")
-
-        if action_type == "update_focus" and not parameters.get("focus"):
-            errors.append("Focus 'focus' parameter required")
-
-        return {
-            "valid": len(errors) == 0,
-            "action": action_type,
-            "errors": errors
-        }
-
-
-# Singleton instance
-_action_manager_instance = None
-
-
-def get_action_manager() -> AutonomousActionManager:
-    """
-    Get singleton action manager instance.
-
-    Returns:
-        AutonomousActionManager instance
-    """
-    global _action_manager_instance
-    if _action_manager_instance is None:
-        _action_manager_instance = AutonomousActionManager()
-    return _action_manager_instance

cortex/autonomy/executive/__init__.py

@@ -1 +0,0 @@
-"""Executive planning and decision-making module."""

cortex/autonomy/executive/planner.py

@@ -1,121 +0,0 @@
-"""
-Executive planner - generates execution plans for complex requests.
-Activated when inner monologue sets consult_executive=true.
-"""
-
-import os
-import logging
-from typing import Dict, Any, Optional
-from llm.llm_router import call_llm
-
-EXECUTIVE_LLM = os.getenv("EXECUTIVE_LLM", "CLOUD").upper()
-VERBOSE_DEBUG = os.getenv("VERBOSE_DEBUG", "false").lower() == "true"
-
-logger = logging.getLogger(__name__)
-
-if VERBOSE_DEBUG:
-    logger.setLevel(logging.DEBUG)
-
-
-EXECUTIVE_SYSTEM_PROMPT = """
-You are Lyra's executive planning system.
-You create structured execution plans for complex tasks.
-You do NOT generate the final response - only the plan.
-
-Your plan should include:
-1. Task decomposition (break into steps)
-2. Required tools/resources
-3. Reasoning strategy
-4. Success criteria
-
-Return a concise plan in natural language.
-"""
-
-
-async def plan_execution(
-    user_prompt: str,
-    intent: str,
-    context_state: Dict[str, Any],
-    identity_block: Dict[str, Any]
-) -> Dict[str, Any]:
-    """
-    Generate execution plan for complex request.
-
-    Args:
-        user_prompt: User's message
-        intent: Detected intent from inner monologue
-        context_state: Full context
-        identity_block: Lyra's identity
-
-    Returns:
-        Plan dictionary with structure:
-        {
-            "summary": "One-line plan summary",
-            "plan_text": "Detailed plan",
-            "steps": ["step1", "step2", ...],
-            "tools_needed": ["RAG", "WEB", ...],
-            "estimated_complexity": "low | medium | high"
-        }
-    """
-
-    # Build planning prompt
-    tools_available = context_state.get("tools_available", [])
-
-    prompt = f"""{EXECUTIVE_SYSTEM_PROMPT}
-
-User request: {user_prompt}
-
-Detected intent: {intent}
-
-Available tools: {", ".join(tools_available) if tools_available else "None"}
-
-Session context:
-- Message count: {context_state.get('message_count', 0)}
-- Time since last message: {context_state.get('minutes_since_last_msg', 0):.1f} minutes
-- Active project: {context_state.get('active_project', 'None')}
-
-Generate a structured execution plan.
-"""
-
-    if VERBOSE_DEBUG:
-        logger.debug(f"[EXECUTIVE] Planning prompt:\n{prompt}")
-
-    # Call executive LLM
-    plan_text = await call_llm(
-        prompt,
-        backend=EXECUTIVE_LLM,
-        temperature=0.3,  # Lower temperature for planning
-        max_tokens=500
-    )
-
-    if VERBOSE_DEBUG:
-        logger.debug(f"[EXECUTIVE] Generated plan:\n{plan_text}")
-
-    # Parse plan (simple heuristic extraction for Phase 1)
-    steps = []
-    tools_needed = []
-
-    for line in plan_text.split('\n'):
-        line_lower = line.lower()
-        if any(marker in line_lower for marker in ['step', '1.', '2.', '3.', '-']):
-            steps.append(line.strip())
-
-        if tools_available:
-            for tool in tools_available:
-                if tool.lower() in line_lower and tool not in tools_needed:
-                    tools_needed.append(tool)
-
-    # Estimate complexity (simple heuristic)
-    complexity = "low"
-    if len(steps) > 3 or len(tools_needed) > 1:
-        complexity = "medium"
-    if len(steps) > 5 or "research" in intent.lower() or "analyze" in intent.lower():
-        complexity = "high"
-
-    return {
-        "summary": plan_text.split('\n')[0][:100] if plan_text else "Complex task execution plan",
-        "plan_text": plan_text,
-        "steps": steps[:10],  # Limit to 10 steps
-        "tools_needed": tools_needed,
-        "estimated_complexity": complexity
-    }

cortex/autonomy/learning/__init__.py

@@ -1 +0,0 @@
-"""Pattern learning and adaptation system."""

cortex/autonomy/learning/pattern_learner.py

@@ -1,383 +0,0 @@
-"""
-Pattern Learning System - learns from interaction patterns to improve autonomy.
-"""
-
-import logging
-import json
-import os
-from typing import Dict, List, Any, Optional
-from datetime import datetime
-from collections import defaultdict
-
-logger = logging.getLogger(__name__)
-
-
-class PatternLearner:
-    """
-    Learns from interaction patterns to improve Lyra's autonomous behavior.
-
-    Tracks:
-    - Topic frequencies (what users talk about)
-    - Time-of-day patterns (when users interact)
-    - User preferences (how users like responses)
-    - Successful response strategies (what works well)
-    """
-
-    def __init__(self, patterns_file: str = "/app/data/learned_patterns.json"):
-        """
-        Initialize pattern learner.
-
-        Args:
-            patterns_file: Path to persistent patterns storage
-        """
-        self.patterns_file = patterns_file
-        self.patterns = self._load_patterns()
-
-    def _load_patterns(self) -> Dict[str, Any]:
-        """Load patterns from disk."""
-        if os.path.exists(self.patterns_file):
-            try:
-                with open(self.patterns_file, 'r') as f:
-                    patterns = json.load(f)
-                    logger.info(f"[PATTERN_LEARNER] Loaded patterns from {self.patterns_file}")
-                    return patterns
-            except Exception as e:
-                logger.error(f"[PATTERN_LEARNER] Failed to load patterns: {e}")
-
-        # Initialize empty patterns
-        return {
-            "topic_frequencies": {},
-            "time_patterns": {},
-            "user_preferences": {},
-            "successful_strategies": {},
-            "interaction_count": 0,
-            "last_updated": datetime.utcnow().isoformat()
-        }
-
-    def _save_patterns(self) -> None:
-        """Save patterns to disk."""
-        try:
-            # Ensure directory exists
-            os.makedirs(os.path.dirname(self.patterns_file), exist_ok=True)
-
-            self.patterns["last_updated"] = datetime.utcnow().isoformat()
-
-            with open(self.patterns_file, 'w') as f:
-                json.dump(self.patterns, f, indent=2)
-
-            logger.debug(f"[PATTERN_LEARNER] Saved patterns to {self.patterns_file}")
-
-        except Exception as e:
-            logger.error(f"[PATTERN_LEARNER] Failed to save patterns: {e}")
-
-    async def learn_from_interaction(
-        self,
-        user_prompt: str,
-        response: str,
-        monologue: Dict[str, Any],
-        context: Dict[str, Any]
-    ) -> None:
-        """
-        Learn from a single interaction.
-
-        Args:
-            user_prompt: User's message
-            response: Lyra's response
-            monologue: Inner monologue analysis
-            context: Full context state
-        """
-        self.patterns["interaction_count"] += 1
-
-        # Learn topic frequencies
-        self._learn_topics(user_prompt, monologue)
-
-        # Learn time patterns
-        self._learn_time_patterns()
-
-        # Learn user preferences
-        self._learn_preferences(monologue, context)
-
-        # Learn successful strategies
-        self._learn_strategies(monologue, response, context)
-
-        # Save periodically (every 10 interactions)
-        if self.patterns["interaction_count"] % 10 == 0:
-            self._save_patterns()
-
-    def _learn_topics(self, user_prompt: str, monologue: Dict[str, Any]) -> None:
-        """Track topic frequencies."""
-        intent = monologue.get("intent", "unknown")
-
-        # Increment topic counter
-        topic_freq = self.patterns["topic_frequencies"]
-        topic_freq[intent] = topic_freq.get(intent, 0) + 1
-
-        # Extract keywords (simple approach - words > 5 chars)
-        keywords = [word.lower() for word in user_prompt.split() if len(word) > 5]
-
-        for keyword in keywords:
-            topic_freq[f"keyword:{keyword}"] = topic_freq.get(f"keyword:{keyword}", 0) + 1
-
-        logger.debug(f"[PATTERN_LEARNER] Topic learned: {intent}")
-
-    def _learn_time_patterns(self) -> None:
-        """Track time-of-day patterns."""
-        now = datetime.utcnow()
-        hour = now.hour
-
-        # Track interactions by hour
-        time_patterns = self.patterns["time_patterns"]
-        hour_key = f"hour_{hour:02d}"
-        time_patterns[hour_key] = time_patterns.get(hour_key, 0) + 1
-
-        # Track day of week
-        day_key = f"day_{now.strftime('%A').lower()}"
-        time_patterns[day_key] = time_patterns.get(day_key, 0) + 1
-
-    def _learn_preferences(self, monologue: Dict[str, Any], context: Dict[str, Any]) -> None:
-        """Learn user preferences from detected tone and depth."""
-        tone = monologue.get("tone", "neutral")
-        depth = monologue.get("depth", "medium")
-
-        prefs = self.patterns["user_preferences"]
-
-        # Track preferred tone
-        prefs.setdefault("tone_counts", {})
-        prefs["tone_counts"][tone] = prefs["tone_counts"].get(tone, 0) + 1
-
-        # Track preferred depth
-        prefs.setdefault("depth_counts", {})
-        prefs["depth_counts"][depth] = prefs["depth_counts"].get(depth, 0) + 1
-
-    def _learn_strategies(
-        self,
-        monologue: Dict[str, Any],
-        response: str,
-        context: Dict[str, Any]
-    ) -> None:
-        """
-        Learn which response strategies are successful.
-
-        Success indicators:
-        - Executive was consulted and plan generated
-        - Response length matches depth request
-        - Tone matches request
-        """
-        intent = monologue.get("intent", "unknown")
-        executive_used = context.get("executive_plan") is not None
-
-        strategies = self.patterns["successful_strategies"]
-        strategies.setdefault(intent, {})
-
-        # Track executive usage for this intent
-        if executive_used:
-            key = f"{intent}:executive_used"
-            strategies.setdefault(key, 0)
-            strategies[key] += 1
-
-        # Track response length patterns
-        response_length = len(response.split())
-        depth = monologue.get("depth", "medium")
-
-        length_key = f"{depth}:avg_words"
-        if length_key not in strategies:
-            strategies[length_key] = response_length
-        else:
-            # Running average
-            strategies[length_key] = (strategies[length_key] + response_length) / 2
-
-    # ========================================
-    # Pattern Analysis and Recommendations
-    # ========================================
-
-    def get_top_topics(self, limit: int = 10) -> List[tuple]:
-        """
-        Get most frequent topics.
-
-        Args:
-            limit: Max number of topics to return
-
-        Returns:
-            List of (topic, count) tuples, sorted by count
-        """
-        topics = self.patterns["topic_frequencies"]
-        sorted_topics = sorted(topics.items(), key=lambda x: x[1], reverse=True)
-        return sorted_topics[:limit]
-
-    def get_preferred_tone(self) -> str:
-        """
-        Get user's most preferred tone.
-
-        Returns:
-            Preferred tone string
-        """
-        prefs = self.patterns["user_preferences"]
-        tone_counts = prefs.get("tone_counts", {})
-
-        if not tone_counts:
-            return "neutral"
-
-        return max(tone_counts.items(), key=lambda x: x[1])[0]
-
-    def get_preferred_depth(self) -> str:
-        """
-        Get user's most preferred response depth.
-
-        Returns:
-            Preferred depth string
-        """
-        prefs = self.patterns["user_preferences"]
-        depth_counts = prefs.get("depth_counts", {})
-
-        if not depth_counts:
-            return "medium"
-
-        return max(depth_counts.items(), key=lambda x: x[1])[0]
-
-    def get_peak_hours(self, limit: int = 3) -> List[int]:
-        """
-        Get peak interaction hours.
-
-        Args:
-            limit: Number of top hours to return
-
-        Returns:
-            List of hours (0-23)
-        """
-        time_patterns = self.patterns["time_patterns"]
-        hour_counts = {k: v for k, v in time_patterns.items() if k.startswith("hour_")}
-
-        if not hour_counts:
-            return []
-
-        sorted_hours = sorted(hour_counts.items(), key=lambda x: x[1], reverse=True)
-        top_hours = sorted_hours[:limit]
-
-        # Extract hour numbers
-        return [int(h[0].split("_")[1]) for h in top_hours]
-
-    def should_use_executive(self, intent: str) -> bool:
-        """
-        Recommend whether to use executive for given intent based on patterns.
-
-        Args:
-            intent: Intent type
-
-        Returns:
-            True if executive is recommended
-        """
-        strategies = self.patterns["successful_strategies"]
-        key = f"{intent}:executive_used"
-
-        # If we've used executive for this intent >= 3 times, recommend it
-        return strategies.get(key, 0) >= 3
-
-    def get_recommended_response_length(self, depth: str) -> int:
-        """
-        Get recommended response length in words for given depth.
-
-        Args:
-            depth: Depth level (short/medium/deep)
-
-        Returns:
-            Recommended word count
-        """
-        strategies = self.patterns["successful_strategies"]
-        key = f"{depth}:avg_words"
-
-        avg_length = strategies.get(key, None)
-
-        if avg_length:
-            return int(avg_length)
-
-        # Defaults if no pattern learned
-        defaults = {
-            "short": 50,
-            "medium": 150,
-            "deep": 300
-        }
-
-        return defaults.get(depth, 150)
-
-    def get_insights(self) -> Dict[str, Any]:
-        """
-        Get high-level insights from learned patterns.
-
-        Returns:
-            {
-                "total_interactions": int,
-                "top_topics": [(topic, count), ...],
-                "preferred_tone": str,
-                "preferred_depth": str,
-                "peak_hours": [hours],
-                "learning_recommendations": [str]
-            }
-        """
-        recommendations = []
-
-        # Check if user consistently prefers certain settings
-        preferred_tone = self.get_preferred_tone()
-        preferred_depth = self.get_preferred_depth()
-
-        if preferred_tone != "neutral":
-            recommendations.append(f"User prefers {preferred_tone} tone")
-
-        if preferred_depth != "medium":
-            recommendations.append(f"User prefers {preferred_depth} depth responses")
-
-        # Check for recurring topics
-        top_topics = self.get_top_topics(limit=3)
-        if top_topics:
-            top_topic = top_topics[0][0]
-            recommendations.append(f"Consider adding '{top_topic}' to learning queue")
-
-        return {
-            "total_interactions": self.patterns["interaction_count"],
-            "top_topics": self.get_top_topics(limit=5),
-            "preferred_tone": preferred_tone,
-            "preferred_depth": preferred_depth,
-            "peak_hours": self.get_peak_hours(limit=3),
-            "learning_recommendations": recommendations
-        }
-
-    def reset_patterns(self) -> None:
-        """Reset all learned patterns (use with caution)."""
-        self.patterns = {
-            "topic_frequencies": {},
-            "time_patterns": {},
-            "user_preferences": {},
-            "successful_strategies": {},
-            "interaction_count": 0,
-            "last_updated": datetime.utcnow().isoformat()
-        }
-        self._save_patterns()
-        logger.warning("[PATTERN_LEARNER] Patterns reset")
-
-    def export_patterns(self) -> Dict[str, Any]:
-        """
-        Export all patterns for analysis.
-
-        Returns:
-            Complete patterns dict
-        """
-        return self.patterns.copy()
-
-
-# Singleton instance
-_learner_instance = None
-
-
-def get_pattern_learner(patterns_file: str = "/app/data/learned_patterns.json") -> PatternLearner:
-    """
-    Get singleton pattern learner instance.
-
-    Args:
-        patterns_file: Path to patterns file (only used on first call)
-
-    Returns:
-        PatternLearner instance
-    """
-    global _learner_instance
-    if _learner_instance is None:
-        _learner_instance = PatternLearner(patterns_file=patterns_file)
-    return _learner_instance

cortex/autonomy/monologue/__init__.py

@@ -1 +0,0 @@
-# Inner monologue module

cortex/autonomy/monologue/monologue.py

@@ -1,115 +0,0 @@
-import os
-import json
-import logging
-from typing import Dict
-from llm.llm_router import call_llm
-
-# Configuration
-MONOLOGUE_LLM = os.getenv("MONOLOGUE_LLM", "PRIMARY").upper()
-VERBOSE_DEBUG = os.getenv("VERBOSE_DEBUG", "false").lower() == "true"
-
-# Logger
-logger = logging.getLogger(__name__)
-
-if VERBOSE_DEBUG:
-    logger.setLevel(logging.DEBUG)
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(logging.Formatter(
-        '%(asctime)s [MONOLOGUE] %(levelname)s: %(message)s',
-        datefmt='%H:%M:%S'
-    ))
-    logger.addHandler(console_handler)
-
-MONOLOGUE_SYSTEM_PROMPT = """
-You are Lyra's inner monologue.
-You think privately.
-You do NOT speak to the user.
-You do NOT solve the task.
-You only reflect on intent, tone, and depth.
-
-Return ONLY valid JSON with:
-- intent (string)
-- tone (neutral | warm | focused | playful | direct)
-- depth (short | medium | deep)
-- consult_executive (true | false)
-"""
-
-class InnerMonologue:
-    async def process(self, context: Dict) -> Dict:
-        # Build full prompt with system instructions merged in
-        full_prompt = f"""{MONOLOGUE_SYSTEM_PROMPT}
-
-User message:
-{context['user_message']}
-
-Self state:
-{context['self_state']}
-
-Context summary:
-{context['context_summary']}
-
-Output JSON only:
-"""
-
-        # Call LLM using configured backend
-        if VERBOSE_DEBUG:
-            logger.debug(f"[InnerMonologue] Calling LLM with backend: {MONOLOGUE_LLM}")
-            logger.debug(f"[InnerMonologue] Prompt length: {len(full_prompt)} chars")
-
-        result = await call_llm(
-            full_prompt,
-            backend=MONOLOGUE_LLM,
-            temperature=0.7,
-            max_tokens=200
-        )
-
-        if VERBOSE_DEBUG:
-            logger.debug(f"[InnerMonologue] Raw LLM response:")
-            logger.debug(f"{'='*80}")
-            logger.debug(result)
-            logger.debug(f"{'='*80}")
-            logger.debug(f"[InnerMonologue] Response length: {len(result) if result else 0} chars")
-
-        # Parse JSON response - extract just the JSON part if there's extra text
-        try:
-            # Try direct parsing first
-            parsed = json.loads(result)
-            if VERBOSE_DEBUG:
-                logger.debug(f"[InnerMonologue] Successfully parsed JSON directly: {parsed}")
-            return parsed
-        except json.JSONDecodeError:
-            # If direct parsing fails, try to extract JSON from the response
-            if VERBOSE_DEBUG:
-                logger.debug(f"[InnerMonologue] Direct JSON parse failed, attempting extraction...")
-
-            # Look for JSON object (starts with { and ends with })
-            import re
-            json_match = re.search(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', result, re.DOTALL)
-
-            if json_match:
-                json_str = json_match.group(0)
-                try:
-                    parsed = json.loads(json_str)
-                    if VERBOSE_DEBUG:
-                        logger.debug(f"[InnerMonologue] Successfully extracted and parsed JSON: {parsed}")
-                    return parsed
-                except json.JSONDecodeError as e:
-                    if VERBOSE_DEBUG:
-                        logger.warning(f"[InnerMonologue] Extracted JSON still invalid: {e}")
-            else:
-                if VERBOSE_DEBUG:
-                    logger.warning(f"[InnerMonologue] No JSON object found in response")
-
-            # Final fallback
-            if VERBOSE_DEBUG:
-                logger.warning(f"[InnerMonologue] All parsing attempts failed, using fallback")
-            else:
-                print(f"[InnerMonologue] JSON extraction failed")
-                print(f"[InnerMonologue] Raw response was: {result[:500]}")
-
-            return {
-                "intent": "unknown",
-                "tone": "neutral",
-                "depth": "medium",
-                "consult_executive": False
-            }

cortex/autonomy/proactive/__init__.py

@@ -1 +0,0 @@
-"""Proactive monitoring and suggestion system."""

cortex/autonomy/proactive/monitor.py

@@ -1,321 +0,0 @@
-"""
-Proactive Context Monitor - detects opportunities for autonomous suggestions.
-"""
-
-import logging
-import time
-from typing import Dict, List, Any, Optional
-from datetime import datetime, timedelta
-
-logger = logging.getLogger(__name__)
-
-
-class ProactiveMonitor:
-    """
-    Monitors conversation context and detects opportunities for proactive suggestions.
-
-    Triggers:
-    - Long silence → Check-in
-    - Learning queue + high curiosity → Suggest exploration
-    - Active goals → Progress reminders
-    - Conversation milestones → Offer summary
-    - Pattern detection → Helpful suggestions
-    """
-
-    def __init__(self, min_priority: float = 0.6):
-        """
-        Initialize proactive monitor.
-
-        Args:
-            min_priority: Minimum priority for suggestions (0.0-1.0)
-        """
-        self.min_priority = min_priority
-        self.last_suggestion_time = {}  # session_id -> timestamp
-        self.cooldown_seconds = 300  # 5 minutes between proactive suggestions
-
-    async def analyze_session(
-        self,
-        session_id: str,
-        context_state: Dict[str, Any],
-        self_state: Dict[str, Any]
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Analyze session for proactive suggestion opportunities.
-
-        Args:
-            session_id: Current session ID
-            context_state: Full context including message history
-            self_state: Lyra's current self-state
-
-        Returns:
-            {
-                "suggestion": "text to append to response",
-                "priority": 0.0-1.0,
-                "reason": "why this suggestion",
-                "type": "check_in | learning | goal_reminder | summary | pattern"
-            }
-            or None if no suggestion
-        """
-        # Check cooldown
-        if not self._check_cooldown(session_id):
-            logger.debug(f"[PROACTIVE] Session {session_id} in cooldown, skipping")
-            return None
-
-        suggestions = []
-
-        # Check 1: Long silence detection
-        silence_suggestion = self._check_long_silence(context_state)
-        if silence_suggestion:
-            suggestions.append(silence_suggestion)
-
-        # Check 2: Learning queue + high curiosity
-        learning_suggestion = self._check_learning_opportunity(self_state)
-        if learning_suggestion:
-            suggestions.append(learning_suggestion)
-
-        # Check 3: Active goals reminder
-        goal_suggestion = self._check_active_goals(self_state, context_state)
-        if goal_suggestion:
-            suggestions.append(goal_suggestion)
-
-        # Check 4: Conversation milestones
-        milestone_suggestion = self._check_conversation_milestone(context_state)
-        if milestone_suggestion:
-            suggestions.append(milestone_suggestion)
-
-        # Check 5: Pattern-based suggestions
-        pattern_suggestion = self._check_patterns(context_state, self_state)
-        if pattern_suggestion:
-            suggestions.append(pattern_suggestion)
-
-        # Filter by priority and return highest
-        valid_suggestions = [s for s in suggestions if s["priority"] >= self.min_priority]
-
-        if not valid_suggestions:
-            return None
-
-        # Return highest priority suggestion
-        best_suggestion = max(valid_suggestions, key=lambda x: x["priority"])
-
-        # Update cooldown timer
-        self._update_cooldown(session_id)
-
-        logger.info(f"[PROACTIVE] Suggestion generated: {best_suggestion['type']} (priority: {best_suggestion['priority']:.2f})")
-
-        return best_suggestion
-
-    def _check_cooldown(self, session_id: str) -> bool:
-        """Check if session is past cooldown period."""
-        if session_id not in self.last_suggestion_time:
-            return True
-
-        elapsed = time.time() - self.last_suggestion_time[session_id]
-        return elapsed >= self.cooldown_seconds
-
-    def _update_cooldown(self, session_id: str) -> None:
-        """Update cooldown timer for session."""
-        self.last_suggestion_time[session_id] = time.time()
-
-    def _check_long_silence(self, context_state: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        """
-        Check if user has been silent for a long time.
-        """
-        minutes_since_last = context_state.get("minutes_since_last_msg", 0)
-
-        # If > 30 minutes, suggest check-in
-        if minutes_since_last > 30:
-            return {
-                "suggestion": "\n\n[Aside: I'm still here if you need anything!]",
-                "priority": 0.7,
-                "reason": f"User silent for {minutes_since_last:.0f} minutes",
-                "type": "check_in"
-            }
-
-        return None
-
-    def _check_learning_opportunity(self, self_state: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        """
-        Check if Lyra has learning queue items and high curiosity.
-        """
-        learning_queue = self_state.get("learning_queue", [])
-        curiosity = self_state.get("curiosity", 0.5)
-
-        # If curiosity > 0.7 and learning queue exists
-        if curiosity > 0.7 and learning_queue:
-            topic = learning_queue[0] if learning_queue else "new topics"
-            return {
-                "suggestion": f"\n\n[Aside: I've been curious about {topic} lately. Would you like to explore it together?]",
-                "priority": 0.65,
-                "reason": f"High curiosity ({curiosity:.2f}) and learning queue present",
-                "type": "learning"
-            }
-
-        return None
-
-    def _check_active_goals(
-        self,
-        self_state: Dict[str, Any],
-        context_state: Dict[str, Any]
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Check if there are active goals worth reminding about.
-        """
-        active_goals = self_state.get("active_goals", [])
-
-        if not active_goals:
-            return None
-
-        # Check if we've had multiple messages without goal progress
-        message_count = context_state.get("message_count", 0)
-
-        # Every 10 messages, consider goal reminder
-        if message_count % 10 == 0 and message_count > 0:
-            goal = active_goals[0]  # First active goal
-            goal_name = goal if isinstance(goal, str) else goal.get("name", "your goal")
-
-            return {
-                "suggestion": f"\n\n[Aside: Still thinking about {goal_name}. Let me know if you want to work on it.]",
-                "priority": 0.6,
-                "reason": f"Active goal present, {message_count} messages since start",
-                "type": "goal_reminder"
-            }
-
-        return None
-
-    def _check_conversation_milestone(self, context_state: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        """
-        Check for conversation milestones (e.g., every 50 messages).
-        """
-        message_count = context_state.get("message_count", 0)
-
-        # Every 50 messages, offer summary
-        if message_count > 0 and message_count % 50 == 0:
-            return {
-                "suggestion": f"\n\n[Aside: We've exchanged {message_count} messages! Would you like a summary of our conversation?]",
-                "priority": 0.65,
-                "reason": f"Milestone: {message_count} messages",
-                "type": "summary"
-            }
-
-        return None
-
-    def _check_patterns(
-        self,
-        context_state: Dict[str, Any],
-        self_state: Dict[str, Any]
-    ) -> Optional[Dict[str, Any]]:
-        """
-        Check for behavioral patterns that merit suggestions.
-        """
-        # Get current focus
-        focus = self_state.get("focus", "")
-
-        # Check if user keeps asking similar questions (detected via focus)
-        if focus and "repeated" in focus.lower():
-            return {
-                "suggestion": "\n\n[Aside: I notice we keep coming back to this topic. Would it help to create a summary or action plan?]",
-                "priority": 0.7,
-                "reason": "Repeated topic detected",
-                "type": "pattern"
-            }
-
-        # Check energy levels - if Lyra is low energy, maybe suggest break
-        energy = self_state.get("energy", 0.8)
-        if energy < 0.3:
-            return {
-                "suggestion": "\n\n[Aside: We've been at this for a while. Need a break or want to keep going?]",
-                "priority": 0.65,
-                "reason": f"Low energy ({energy:.2f})",
-                "type": "pattern"
-            }
-
-        return None
-
-    def format_suggestion(self, suggestion: Dict[str, Any]) -> str:
-        """
-        Format suggestion for appending to response.
-
-        Args:
-            suggestion: Suggestion dict from analyze_session()
-
-        Returns:
-            Formatted string to append to response
-        """
-        return suggestion.get("suggestion", "")
-
-    def set_cooldown_duration(self, seconds: int) -> None:
-        """
-        Update cooldown duration.
-
-        Args:
-            seconds: New cooldown duration
-        """
-        self.cooldown_seconds = seconds
-        logger.info(f"[PROACTIVE] Cooldown updated to {seconds}s")
-
-    def reset_cooldown(self, session_id: str) -> None:
-        """
-        Reset cooldown for a specific session.
-
-        Args:
-            session_id: Session to reset
-        """
-        if session_id in self.last_suggestion_time:
-            del self.last_suggestion_time[session_id]
-            logger.info(f"[PROACTIVE] Cooldown reset for session {session_id}")
-
-    def get_session_stats(self, session_id: str) -> Dict[str, Any]:
-        """
-        Get stats for a session's proactive monitoring.
-
-        Args:
-            session_id: Session to check
-
-        Returns:
-            {
-                "last_suggestion_time": timestamp or None,
-                "seconds_since_last": int,
-                "cooldown_active": bool,
-                "cooldown_remaining": int
-            }
-        """
-        last_time = self.last_suggestion_time.get(session_id)
-
-        if not last_time:
-            return {
-                "last_suggestion_time": None,
-                "seconds_since_last": 0,
-                "cooldown_active": False,
-                "cooldown_remaining": 0
-            }
-
-        seconds_since = int(time.time() - last_time)
-        cooldown_active = seconds_since < self.cooldown_seconds
-        cooldown_remaining = max(0, self.cooldown_seconds - seconds_since)
-
-        return {
-            "last_suggestion_time": last_time,
-            "seconds_since_last": seconds_since,
-            "cooldown_active": cooldown_active,
-            "cooldown_remaining": cooldown_remaining
-        }
-
-
-# Singleton instance
-_monitor_instance = None
-
-
-def get_proactive_monitor(min_priority: float = 0.6) -> ProactiveMonitor:
-    """
-    Get singleton proactive monitor instance.
-
-    Args:
-        min_priority: Minimum priority threshold (only used on first call)
-
-    Returns:
-        ProactiveMonitor instance
-    """
-    global _monitor_instance
-    if _monitor_instance is None:
-        _monitor_instance = ProactiveMonitor(min_priority=min_priority)
-    return _monitor_instance

cortex/autonomy/self/__init__.py

@@ -1 +0,0 @@
-# Self state module

cortex/autonomy/self/analyzer.py

@@ -1,74 +0,0 @@
-"""
-Analyze interactions and update self-state accordingly.
-"""
-
-import logging
-from typing import Dict, Any
-from .state import update_self_state
-
-logger = logging.getLogger(__name__)
-
-
-async def analyze_and_update_state(
-    monologue: Dict[str, Any],
-    user_prompt: str,
-    response: str,
-    context: Dict[str, Any]
-) -> None:
-    """
-    Analyze interaction and update self-state.
-
-    This runs after response generation to update Lyra's internal state
-    based on the interaction.
-
-    Args:
-        monologue: Inner monologue output
-        user_prompt: User's message
-        response: Lyra's response
-        context: Full context state
-    """
-
-    # Simple heuristics for state updates
-    # TODO: Replace with LLM-based sentiment analysis in Phase 2
-
-    mood_delta = 0.0
-    energy_delta = 0.0
-    confidence_delta = 0.0
-    curiosity_delta = 0.0
-    new_focus = None
-
-    # Analyze intent from monologue
-    intent = monologue.get("intent", "").lower() if monologue else ""
-
-    if "technical" in intent or "complex" in intent:
-        energy_delta = -0.05  # Deep thinking is tiring
-        confidence_delta = 0.05 if len(response) > 200 else -0.05
-        new_focus = "technical_problem"
-
-    elif "creative" in intent or "brainstorm" in intent:
-        mood_delta = 0.1  # Creative work is engaging
-        curiosity_delta = 0.1
-        new_focus = "creative_exploration"
-
-    elif "clarification" in intent or "confused" in intent:
-        confidence_delta = -0.05
-        new_focus = "understanding_user"
-
-    elif "simple" in intent or "casual" in intent:
-        energy_delta = 0.05  # Light conversation is refreshing
-        new_focus = "conversation"
-
-    # Check for learning opportunities (questions in user prompt)
-    if "?" in user_prompt and any(word in user_prompt.lower() for word in ["how", "why", "what"]):
-        curiosity_delta += 0.05
-
-    # Update state
-    update_self_state(
-        mood_delta=mood_delta,
-        energy_delta=energy_delta,
-        new_focus=new_focus,
-        confidence_delta=confidence_delta,
-        curiosity_delta=curiosity_delta
-    )
-
-    logger.info(f"Self-state updated based on interaction: focus={new_focus}")

cortex/autonomy/self/state.py

@@ -1,189 +0,0 @@
-"""
-Self-state management for Project Lyra.
-Maintains persistent identity, mood, energy, and focus across sessions.
-"""
-
-import json
-import logging
-import os
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, Any, Optional
-
-# Configuration
-STATE_FILE = Path(os.getenv("SELF_STATE_FILE", "/app/data/self_state.json"))
-VERBOSE_DEBUG = os.getenv("VERBOSE_DEBUG", "false").lower() == "true"
-
-logger = logging.getLogger(__name__)
-
-if VERBOSE_DEBUG:
-    logger.setLevel(logging.DEBUG)
-
-# Default state structure
-DEFAULT_STATE = {
-    "mood": "neutral",
-    "energy": 0.8,
-    "focus": "user_request",
-    "confidence": 0.7,
-    "curiosity": 0.5,
-    "last_updated": None,
-    "interaction_count": 0,
-    "learning_queue": [],  # Topics Lyra wants to explore
-    "active_goals": [],  # Self-directed goals
-    "preferences": {
-        "verbosity": "medium",
-        "formality": "casual",
-        "proactivity": 0.3  # How likely to suggest things unprompted
-    },
-    "metadata": {
-        "version": "1.0",
-        "created_at": None
-    }
-}
-
-
-class SelfState:
-    """Manages Lyra's persistent self-state."""
-
-    def __init__(self):
-        self._state = self._load_state()
-
-    def _load_state(self) -> Dict[str, Any]:
-        """Load state from disk or create default."""
-        if STATE_FILE.exists():
-            try:
-                with open(STATE_FILE, 'r') as f:
-                    state = json.load(f)
-                    logger.info(f"Loaded self-state from {STATE_FILE}")
-                    return state
-            except Exception as e:
-                logger.error(f"Failed to load self-state: {e}")
-                return self._create_default_state()
-        else:
-            return self._create_default_state()
-
-    def _create_default_state(self) -> Dict[str, Any]:
-        """Create and save default state."""
-        state = DEFAULT_STATE.copy()
-        state["metadata"]["created_at"] = datetime.now().isoformat()
-        state["last_updated"] = datetime.now().isoformat()
-        self._save_state(state)
-        logger.info("Created new default self-state")
-        return state
-
-    def _save_state(self, state: Dict[str, Any]) -> None:
-        """Persist state to disk."""
-        try:
-            STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
-            with open(STATE_FILE, 'w') as f:
-                json.dump(state, f, indent=2)
-            if VERBOSE_DEBUG:
-                logger.debug(f"Saved self-state to {STATE_FILE}")
-        except Exception as e:
-            logger.error(f"Failed to save self-state: {e}")
-
-    def get_state(self) -> Dict[str, Any]:
-        """Get current state snapshot."""
-        return self._state.copy()
-
-    def update_from_interaction(
-        self,
-        mood_delta: float = 0.0,
-        energy_delta: float = 0.0,
-        new_focus: Optional[str] = None,
-        confidence_delta: float = 0.0,
-        curiosity_delta: float = 0.0
-    ) -> None:
-        """
-        Update state based on interaction.
-
-        Args:
-            mood_delta: Change in mood (-1.0 to 1.0)
-            energy_delta: Change in energy (-1.0 to 1.0)
-            new_focus: New focus area
-            confidence_delta: Change in confidence
-            curiosity_delta: Change in curiosity
-        """
-        # Apply deltas with bounds checking
-        self._state["energy"] = max(0.0, min(1.0,
-            self._state.get("energy", 0.8) + energy_delta))
-
-        self._state["confidence"] = max(0.0, min(1.0,
-            self._state.get("confidence", 0.7) + confidence_delta))
-
-        self._state["curiosity"] = max(0.0, min(1.0,
-            self._state.get("curiosity", 0.5) + curiosity_delta))
-
-        # Update focus if provided
-        if new_focus:
-            self._state["focus"] = new_focus
-
-        # Update mood (simplified sentiment)
-        if mood_delta != 0:
-            mood_map = ["frustrated", "neutral", "engaged", "excited"]
-            current_mood_idx = 1  # neutral default
-            if self._state.get("mood") in mood_map:
-                current_mood_idx = mood_map.index(self._state["mood"])
-
-            new_mood_idx = max(0, min(len(mood_map) - 1,
-                int(current_mood_idx + mood_delta * 2)))
-            self._state["mood"] = mood_map[new_mood_idx]
-
-        # Increment interaction counter
-        self._state["interaction_count"] = self._state.get("interaction_count", 0) + 1
-        self._state["last_updated"] = datetime.now().isoformat()
-
-        # Persist changes
-        self._save_state(self._state)
-
-        if VERBOSE_DEBUG:
-            logger.debug(f"Updated self-state: mood={self._state['mood']}, "
-                        f"energy={self._state['energy']:.2f}, "
-                        f"confidence={self._state['confidence']:.2f}")
-
-    def add_learning_goal(self, topic: str) -> None:
-        """Add topic to learning queue."""
-        queue = self._state.get("learning_queue", [])
-        if topic not in [item.get("topic") for item in queue]:
-            queue.append({
-                "topic": topic,
-                "added_at": datetime.now().isoformat(),
-                "priority": 0.5
-            })
-            self._state["learning_queue"] = queue
-            self._save_state(self._state)
-            logger.info(f"Added learning goal: {topic}")
-
-    def add_active_goal(self, goal: str, context: str = "") -> None:
-        """Add self-directed goal."""
-        goals = self._state.get("active_goals", [])
-        goals.append({
-            "goal": goal,
-            "context": context,
-            "created_at": datetime.now().isoformat(),
-            "status": "active"
-        })
-        self._state["active_goals"] = goals
-        self._save_state(self._state)
-        logger.info(f"Added active goal: {goal}")
-
-
-# Global instance
-_self_state_instance = None
-
-def get_self_state_instance() -> SelfState:
-    """Get or create global SelfState instance."""
-    global _self_state_instance
-    if _self_state_instance is None:
-        _self_state_instance = SelfState()
-    return _self_state_instance
-
-
-def load_self_state() -> Dict[str, Any]:
-    """Load self state - public API for backwards compatibility."""
-    return get_self_state_instance().get_state()
-
-
-def update_self_state(**kwargs) -> None:
-    """Update self state - public API."""
-    get_self_state_instance().update_from_interaction(**kwargs)

cortex/autonomy/tools/__init__.py

@@ -1 +0,0 @@
-"""Autonomous tool invocation system."""

cortex/autonomy/tools/adapters/__init__.py

@@ -1,13 +0,0 @@
-"""Provider adapters for tool calling."""
-
-from .base import ToolAdapter
-from .openai_adapter import OpenAIAdapter
-from .ollama_adapter import OllamaAdapter
-from .llamacpp_adapter import LlamaCppAdapter
-
-__all__ = [
-    "ToolAdapter",
-    "OpenAIAdapter",
-    "OllamaAdapter",
-    "LlamaCppAdapter",
-]

cortex/autonomy/tools/adapters/base.py

@@ -1,79 +0,0 @@
-"""
-Base adapter interface for provider-agnostic tool calling.
-
-This module defines the abstract base class that all LLM provider adapters
-must implement to support tool calling in Lyra.
-"""
-
-from abc import ABC, abstractmethod
-from typing import Dict, List, Optional
-
-
-class ToolAdapter(ABC):
-    """Base class for provider-specific tool adapters.
-
-    Each LLM provider (OpenAI, Ollama, llama.cpp, etc.) has its own
-    way of handling tool calls. This adapter pattern allows Lyra to
-    support tools across all providers with a unified interface.
-    """
-
-    @abstractmethod
-    async def prepare_request(
-        self,
-        messages: List[Dict],
-        tools: List[Dict],
-        tool_choice: Optional[str] = None
-    ) -> Dict:
-        """Convert Lyra tool definitions to provider-specific format.
-
-        Args:
-            messages: Conversation history in OpenAI format
-            tools: List of Lyra tool definitions (provider-agnostic)
-            tool_choice: Optional tool forcing ("auto", "required", "none")
-
-        Returns:
-            dict: Provider-specific request payload ready to send to LLM
-        """
-        pass
-
-    @abstractmethod
-    async def parse_response(self, response) -> Dict:
-        """Extract tool calls from provider response.
-
-        Args:
-            response: Raw provider response (format varies by provider)
-
-        Returns:
-            dict: Standardized response in Lyra format:
-                {
-                    "content": str,  # Assistant's text response
-                    "tool_calls": [  # List of tool calls or None
-                        {
-                            "id": str,       # Unique call ID
-                            "name": str,     # Tool name
-                            "arguments": dict  # Tool arguments
-                        }
-                    ] or None
-                }
-        """
-        pass
-
-    @abstractmethod
-    def format_tool_result(
-        self,
-        tool_call_id: str,
-        tool_name: str,
-        result: Dict
-    ) -> Dict:
-        """Format tool execution result for next LLM call.
-
-        Args:
-            tool_call_id: ID from the original tool call
-            tool_name: Name of the executed tool
-            result: Tool execution result dictionary
-
-        Returns:
-            dict: Message object to append to conversation
-                (format varies by provider)
-        """
-        pass

cortex/autonomy/tools/adapters/llamacpp_adapter.py

@@ -1,17 +0,0 @@
-"""
-llama.cpp adapter for tool calling.
-
-Since llama.cpp has similar constraints to Ollama (no native function calling),
-this adapter reuses the XML-based approach from OllamaAdapter.
-"""
-
-from .ollama_adapter import OllamaAdapter
-
-
-class LlamaCppAdapter(OllamaAdapter):
-    """llama.cpp adapter - uses same XML approach as Ollama.
-
-    llama.cpp doesn't have native function calling support, so we use
-    the same XML-based prompt engineering approach as Ollama.
-    """
-    pass

cortex/autonomy/tools/adapters/ollama_adapter.py

@@ -1,191 +0,0 @@
-"""
-Ollama adapter for tool calling using XML-structured prompts.
-
-Since Ollama doesn't have native function calling, this adapter uses
-XML-based prompts to instruct the model how to call tools.
-"""
-
-import json
-import re
-from typing import Dict, List, Optional
-from .base import ToolAdapter
-
-
-class OllamaAdapter(ToolAdapter):
-    """Ollama adapter using XML-structured prompts for tool calling.
-
-    This adapter injects tool descriptions into the system prompt and
-    teaches the model to respond with XML when it wants to use a tool.
-    """
-
-    SYSTEM_PROMPT = """You have access to the following tools:
-
-{tool_descriptions}
-
-To use a tool, respond with XML in this exact format:
-<tool_call>
-  <name>tool_name</name>
-  <arguments>
-    <arg_name>value</arg_name>
-  </arguments>
-  <reason>why you're using this tool</reason>
-</tool_call>
-
-You can call multiple tools by including multiple <tool_call> blocks.
-If you don't need to use any tools, respond normally without XML.
-After tools are executed, you'll receive results and can continue the conversation."""
-
-    async def prepare_request(
-        self,
-        messages: List[Dict],
-        tools: List[Dict],
-        tool_choice: Optional[str] = None
-    ) -> Dict:
-        """Inject tool descriptions into system prompt.
-
-        Args:
-            messages: Conversation history
-            tools: Lyra tool definitions
-            tool_choice: Ignored for Ollama (no native support)
-
-        Returns:
-            dict: Request payload with modified messages
-        """
-        # Format tool descriptions
-        tool_desc = "\n".join([
-            f"- {t['name']}: {t['description']}\n  Parameters: {self._format_parameters(t['parameters'], t.get('required', []))}"
-            for t in tools
-        ])
-
-        system_msg = self.SYSTEM_PROMPT.format(tool_descriptions=tool_desc)
-
-        # Check if first message is already a system message
-        modified_messages = messages.copy()
-        if modified_messages and modified_messages[0].get("role") == "system":
-            # Prepend tool instructions to existing system message
-            modified_messages[0]["content"] = system_msg + "\n\n" + modified_messages[0]["content"]
-        else:
-            # Add new system message at the beginning
-            modified_messages.insert(0, {"role": "system", "content": system_msg})
-
-        return {"messages": modified_messages}
-
-    def _format_parameters(self, parameters: Dict, required: List[str]) -> str:
-        """Format parameters for tool description.
-
-        Args:
-            parameters: Parameter definitions
-            required: List of required parameter names
-
-        Returns:
-            str: Human-readable parameter description
-        """
-        param_strs = []
-        for name, spec in parameters.items():
-            req_marker = "(required)" if name in required else "(optional)"
-            param_strs.append(f"{name} {req_marker}: {spec.get('description', '')}")
-        return ", ".join(param_strs)
-
-    async def parse_response(self, response) -> Dict:
-        """Extract tool calls from XML in response.
-
-        Args:
-            response: String response from Ollama
-
-        Returns:
-            dict: Standardized Lyra format with content and tool_calls
-        """
-        import logging
-        logger = logging.getLogger(__name__)
-
-        # Ollama returns a string
-        if isinstance(response, dict):
-            content = response.get("message", {}).get("content", "")
-        else:
-            content = str(response)
-
-        logger.info(f"🔍 OllamaAdapter.parse_response: content length={len(content)}, has <tool_call>={('<tool_call>' in content)}")
-        logger.debug(f"🔍 Content preview: {content[:500]}")
-
-        # Parse XML tool calls
-        tool_calls = []
-        if "<tool_call>" in content:
-            # Split content by <tool_call> to get each block
-            blocks = content.split('<tool_call>')
-            logger.info(f"🔍 Split into {len(blocks)} blocks")
-
-            # First block is content before any tool calls
-            clean_parts = [blocks[0]]
-
-            for idx, block in enumerate(blocks[1:]):  # Skip first block (pre-tool content)
-                # Extract tool name
-                name_match = re.search(r'<name>(.*?)</name>', block)
-                if not name_match:
-                    logger.warning(f"Block {idx} has no <name> tag, skipping")
-                    continue
-
-                name = name_match.group(1).strip()
-                arguments = {}
-
-                # Extract arguments
-                args_match = re.search(r'<arguments>(.*?)</arguments>', block, re.DOTALL)
-                if args_match:
-                    args_xml = args_match.group(1)
-                    # Parse <key>value</key> pairs
-                    arg_pairs = re.findall(r'<(\w+)>(.*?)</\1>', args_xml, re.DOTALL)
-                    arguments = {k: v.strip() for k, v in arg_pairs}
-
-                tool_calls.append({
-                    "id": f"call_{idx}",
-                    "name": name,
-                    "arguments": arguments
-                })
-
-                # For clean content, find what comes AFTER the tool call block
-                # Look for the last closing tag (</tool_call> or malformed </xxx>) and keep what's after
-                # Split by any closing tag at the END of the tool block
-                remaining = block
-                # Remove everything up to and including a standalone closing tag
-                # Pattern: find </something> that's not followed by more XML
-                end_match = re.search(r'</[a-z_]+>\s*(.*)$', remaining, re.DOTALL)
-                if end_match:
-                    after_content = end_match.group(1).strip()
-                    if after_content and not after_content.startswith('<'):
-                        # Only keep if it's actual text content, not more XML
-                        clean_parts.append(after_content)
-
-            clean_content = ''.join(clean_parts).strip()
-        else:
-            clean_content = content
-
-        return {
-            "content": clean_content,
-            "tool_calls": tool_calls if tool_calls else None
-        }
-
-    def format_tool_result(
-        self,
-        tool_call_id: str,
-        tool_name: str,
-        result: Dict
-    ) -> Dict:
-        """Format tool result as XML for next prompt.
-
-        Args:
-            tool_call_id: ID from the original tool call
-            tool_name: Name of the executed tool
-            result: Tool execution result
-
-        Returns:
-            dict: Message in user role with XML-formatted result
-        """
-        # Format result as XML
-        result_xml = f"""<tool_result>
-  <tool>{tool_name}</tool>
-  <result>{json.dumps(result, ensure_ascii=False)}</result>
-</tool_result>"""
-
-        return {
-            "role": "user",
-            "content": result_xml
-        }

cortex/autonomy/tools/adapters/openai_adapter.py

@@ -1,130 +0,0 @@
-"""
-OpenAI adapter for tool calling using native function calling API.
-
-This adapter converts Lyra tool definitions to OpenAI's function calling
-format and parses OpenAI responses back to Lyra's standardized format.
-"""
-
-import json
-from typing import Dict, List, Optional
-from .base import ToolAdapter
-
-
-class OpenAIAdapter(ToolAdapter):
-    """OpenAI-specific adapter using native function calling.
-
-    OpenAI supports function calling natively through the 'tools' parameter
-    in chat completions. This adapter leverages that capability.
-    """
-
-    async def prepare_request(
-        self,
-        messages: List[Dict],
-        tools: List[Dict],
-        tool_choice: Optional[str] = None
-    ) -> Dict:
-        """Convert Lyra tools to OpenAI function calling format.
-
-        Args:
-            messages: Conversation history
-            tools: Lyra tool definitions
-            tool_choice: "auto", "required", "none", or None
-
-        Returns:
-            dict: Request payload with OpenAI-formatted tools
-        """
-        # Convert Lyra tools → OpenAI function calling format
-        openai_tools = []
-        for tool in tools:
-            openai_tools.append({
-                "type": "function",
-                "function": {
-                    "name": tool["name"],
-                    "description": tool["description"],
-                    "parameters": {
-                        "type": "object",
-                        "properties": tool["parameters"],
-                        "required": tool.get("required", [])
-                    }
-                }
-            })
-
-        payload = {
-            "messages": messages,
-            "tools": openai_tools
-        }
-
-        # Add tool_choice if specified
-        if tool_choice:
-            if tool_choice == "required":
-                payload["tool_choice"] = "required"
-            elif tool_choice == "none":
-                payload["tool_choice"] = "none"
-            else:  # "auto" or default
-                payload["tool_choice"] = "auto"
-
-        return payload
-
-    async def parse_response(self, response) -> Dict:
-        """Extract tool calls from OpenAI response.
-
-        Args:
-            response: OpenAI ChatCompletion response object
-
-        Returns:
-            dict: Standardized Lyra format with content and tool_calls
-        """
-        message = response.choices[0].message
-        content = message.content if message.content else ""
-        tool_calls = []
-
-        # Check if response contains tool calls
-        if hasattr(message, 'tool_calls') and message.tool_calls:
-            for tc in message.tool_calls:
-                try:
-                    # Parse arguments (may be JSON string)
-                    args = tc.function.arguments
-                    if isinstance(args, str):
-                        args = json.loads(args)
-
-                    tool_calls.append({
-                        "id": tc.id,
-                        "name": tc.function.name,
-                        "arguments": args
-                    })
-                except json.JSONDecodeError as e:
-                    # If arguments can't be parsed, include error
-                    tool_calls.append({
-                        "id": tc.id,
-                        "name": tc.function.name,
-                        "arguments": {},
-                        "error": f"Failed to parse arguments: {str(e)}"
-                    })
-
-        return {
-            "content": content,
-            "tool_calls": tool_calls if tool_calls else None
-        }
-
-    def format_tool_result(
-        self,
-        tool_call_id: str,
-        tool_name: str,
-        result: Dict
-    ) -> Dict:
-        """Format tool result as OpenAI tool message.
-
-        Args:
-            tool_call_id: ID from the original tool call
-            tool_name: Name of the executed tool
-            result: Tool execution result
-
-        Returns:
-            dict: Message in OpenAI tool message format
-        """
-        return {
-            "role": "tool",
-            "tool_call_id": tool_call_id,
-            "name": tool_name,
-            "content": json.dumps(result, ensure_ascii=False)
-        }

cortex/autonomy/tools/decision_engine.py

@@ -1,124 +0,0 @@
-"""
-Tool Decision Engine - decides which tools to invoke autonomously.
-"""
-
-import logging
-from typing import Dict, List, Any
-
-logger = logging.getLogger(__name__)
-
-
-class ToolDecisionEngine:
-    """Decides which tools to invoke based on context analysis."""
-
-    async def analyze_tool_needs(
-        self,
-        user_prompt: str,
-        monologue: Dict[str, Any],
-        context_state: Dict[str, Any],
-        available_tools: List[str]
-    ) -> Dict[str, Any]:
-        """
-        Analyze if tools should be invoked and which ones.
-
-        Args:
-            user_prompt: User's message
-            monologue: Inner monologue analysis
-            context_state: Full context
-            available_tools: List of available tools
-
-        Returns:
-            {
-                "should_invoke_tools": bool,
-                "tools_to_invoke": [
-                    {
-                        "tool": "RAG | WEB | WEATHER | etc",
-                        "query": "search query",
-                        "reason": "why this tool",
-                        "priority": 0.0-1.0
-                    },
-                    ...
-                ],
-                "confidence": 0.0-1.0
-            }
-        """
-
-        tools_to_invoke = []
-
-        # Check for memory/context needs
-        if any(word in user_prompt.lower() for word in [
-            "remember", "you said", "we discussed", "earlier", "before",
-            "last time", "previously", "what did"
-        ]):
-            tools_to_invoke.append({
-                "tool": "RAG",
-                "query": user_prompt,
-                "reason": "User references past conversation",
-                "priority": 0.9
-            })
-
-        # Check for web search needs
-        if any(word in user_prompt.lower() for word in [
-            "current", "latest", "news", "today", "what's happening",
-            "look up", "search for", "find information", "recent"
-        ]):
-            tools_to_invoke.append({
-                "tool": "WEB",
-                "query": user_prompt,
-                "reason": "Requires current information",
-                "priority": 0.8
-            })
-
-        # Check for weather needs
-        if any(word in user_prompt.lower() for word in [
-            "weather", "temperature", "forecast", "rain", "sunny", "climate"
-        ]):
-            tools_to_invoke.append({
-                "tool": "WEATHER",
-                "query": user_prompt,
-                "reason": "Weather information requested",
-                "priority": 0.95
-            })
-
-        # Check for code-related needs
-        if any(word in user_prompt.lower() for word in [
-            "code", "function", "debug", "implement", "algorithm",
-            "programming", "script", "syntax"
-        ]):
-            if "CODEBRAIN" in available_tools:
-                tools_to_invoke.append({
-                    "tool": "CODEBRAIN",
-                    "query": user_prompt,
-                    "reason": "Code-related task",
-                    "priority": 0.85
-                })
-
-        # Proactive RAG for complex queries (based on monologue)
-        intent = monologue.get("intent", "") if monologue else ""
-        if monologue and monologue.get("consult_executive"):
-            # Complex query - might benefit from context
-            if not any(t["tool"] == "RAG" for t in tools_to_invoke):
-                tools_to_invoke.append({
-                    "tool": "RAG",
-                    "query": user_prompt,
-                    "reason": "Complex query benefits from context",
-                    "priority": 0.6
-                })
-
-        # Sort by priority
-        tools_to_invoke.sort(key=lambda x: x["priority"], reverse=True)
-
-        max_priority = max([t["priority"] for t in tools_to_invoke]) if tools_to_invoke else 0.0
-
-        result = {
-            "should_invoke_tools": len(tools_to_invoke) > 0,
-            "tools_to_invoke": tools_to_invoke,
-            "confidence": max_priority
-        }
-
-        if tools_to_invoke:
-            logger.info(f"[TOOL_DECISION] Autonomous tool invocation recommended: {len(tools_to_invoke)} tools")
-            for tool in tools_to_invoke:
-                logger.info(f"  - {tool['tool']} (priority: {tool['priority']:.2f}): {tool['reason']}")
-
-        return result

cortex/autonomy/tools/executors/__init__.py

@@ -1,12 +0,0 @@
-"""Tool executors for Lyra."""
-
-from .code_executor import execute_code
-from .web_search import search_web
-from .trilium import search_notes, create_note
-
-__all__ = [
-    "execute_code",
-    "search_web",
-    "search_notes",
-    "create_note",
-]

cortex/autonomy/tools/executors/code_executor.py

@@ -1,218 +0,0 @@
-"""
-Code executor for running Python and bash code in a sandbox container.
-
-This module provides secure code execution with timeout protection,
-output limits, and forbidden pattern detection.
-"""
-
-import asyncio
-import os
-import tempfile
-import re
-from typing import Dict
-import docker
-from docker.errors import (
-    DockerException,
-    APIError,
-    ContainerError,
-    ImageNotFound,
-    NotFound
-)
-
-
-# Forbidden patterns that pose security risks
-FORBIDDEN_PATTERNS = [
-    r'rm\s+-rf',  # Destructive file removal
-    r':\(\)\{\s*:\|:&\s*\};:',  # Fork bomb
-    r'mkfs',  # Filesystem formatting
-    r'/dev/sd[a-z]',  # Direct device access
-    r'dd\s+if=',  # Low-level disk operations
-    r'>\s*/dev/sd',  # Writing to devices
-    r'curl.*\|.*sh',  # Pipe to shell (common attack vector)
-    r'wget.*\|.*sh',  # Pipe to shell
-]
-
-
-async def execute_code(args: Dict) -> Dict:
-    """Execute code in sandbox container.
-
-    Args:
-        args: Dictionary containing:
-            - language (str): "python" or "bash"
-            - code (str): The code to execute
-            - reason (str): Why this code is being executed
-            - timeout (int, optional): Execution timeout in seconds
-
-    Returns:
-        dict: Execution result containing:
-            - stdout (str): Standard output
-            - stderr (str): Standard error
-            - exit_code (int): Process exit code
-            - execution_time (float): Time taken in seconds
-            OR
-            - error (str): Error message if execution failed
-    """
-    language = args.get("language")
-    code = args.get("code")
-    reason = args.get("reason", "No reason provided")
-    timeout = args.get("timeout", 30)
-
-    # Validation
-    if not language or language not in ["python", "bash"]:
-        return {"error": "Invalid language. Must be 'python' or 'bash'"}
-
-    if not code:
-        return {"error": "No code provided"}
-
-    # Security: Check for forbidden patterns
-    for pattern in FORBIDDEN_PATTERNS:
-        if re.search(pattern, code, re.IGNORECASE):
-            return {"error": f"Forbidden pattern detected for security reasons"}
-
-    # Validate and cap timeout
-    max_timeout = int(os.getenv("CODE_SANDBOX_MAX_TIMEOUT", "120"))
-    timeout = min(max(timeout, 1), max_timeout)
-
-    container = os.getenv("CODE_SANDBOX_CONTAINER", "lyra-code-sandbox")
-
-    # Validate container exists and is running
-    try:
-        docker_client = docker.from_env()
-        container_obj = docker_client.containers.get(container)
-
-        if container_obj.status != "running":
-            return {
-                "error": f"Sandbox container '{container}' is not running (status: {container_obj.status})",
-                "hint": "Start the container with: docker start " + container
-            }
-    except NotFound:
-        return {
-            "error": f"Sandbox container '{container}' not found",
-            "hint": "Ensure the container exists and is running"
-        }
-    except DockerException as e:
-        return {
-            "error": f"Docker daemon error: {str(e)}",
-            "hint": "Check Docker connectivity and permissions"
-        }
-
-    # Write code to temporary file
-    suffix = ".py" if language == "python" else ".sh"
-    try:
-        with tempfile.NamedTemporaryFile(
-            mode='w',
-            suffix=suffix,
-            delete=False,
-            encoding='utf-8'
-        ) as f:
-            f.write(code)
-            temp_file = f.name
-    except Exception as e:
-        return {"error": f"Failed to create temp file: {str(e)}"}
-
-    try:
-        # Copy file to container
-        exec_path = f"/executions/{os.path.basename(temp_file)}"
-
-        cp_proc = await asyncio.create_subprocess_exec(
-            "docker", "cp", temp_file, f"{container}:{exec_path}",
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        await cp_proc.communicate()
-
-        if cp_proc.returncode != 0:
-            return {"error": "Failed to copy code to sandbox container"}
-
-        # Fix permissions so sandbox user can read the file (run as root)
-        chown_proc = await asyncio.create_subprocess_exec(
-            "docker", "exec", "-u", "root", container, "chown", "sandbox:sandbox", exec_path,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        await chown_proc.communicate()
-
-        # Execute in container as sandbox user
-        if language == "python":
-            cmd = ["docker", "exec", "-u", "sandbox", container, "python3", exec_path]
-        else:  # bash
-            cmd = ["docker", "exec", "-u", "sandbox", container, "bash", exec_path]
-
-        start_time = asyncio.get_event_loop().time()
-
-        proc = await asyncio.create_subprocess_exec(
-            *cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-
-        try:
-            stdout, stderr = await asyncio.wait_for(
-                proc.communicate(),
-                timeout=timeout
-            )
-
-            execution_time = asyncio.get_event_loop().time() - start_time
-
-            # Truncate output to prevent memory issues (configurable)
-            max_output = int(os.getenv("CODE_SANDBOX_MAX_OUTPUT", "10240"))  # 10KB default
-            stdout_str = stdout[:max_output].decode('utf-8', errors='replace')
-            stderr_str = stderr[:max_output].decode('utf-8', errors='replace')
-
-            if len(stdout) > max_output:
-                stdout_str += f"\n... (output truncated, {len(stdout)} bytes total)"
-            if len(stderr) > max_output:
-                stderr_str += f"\n... (output truncated, {len(stderr)} bytes total)"
-
-            return {
-                "stdout": stdout_str,
-                "stderr": stderr_str,
-                "exit_code": proc.returncode,
-                "execution_time": round(execution_time, 2)
-            }
-
-        except asyncio.TimeoutError:
-            # Kill the process
-            try:
-                proc.kill()
-                await proc.wait()
-            except:
-                pass
-            return {"error": f"Execution timeout after {timeout}s"}
-
-    except APIError as e:
-        return {
-            "error": f"Docker API error: {e.explanation}",
-            "status_code": e.status_code
-        }
-    except ContainerError as e:
-        return {
-            "error": f"Container execution error: {str(e)}",
-            "exit_code": e.exit_status
-        }
-    except DockerException as e:
-        return {
-            "error": f"Docker error: {str(e)}",
-            "hint": "Check Docker daemon connectivity and permissions"
-        }
-    except Exception as e:
-        return {"error": f"Execution failed: {str(e)}"}
-
-    finally:
-        # Cleanup temporary file
-        try:
-            if 'temp_file' in locals():
-                os.unlink(temp_file)
-        except Exception as cleanup_error:
-            # Log but don't fail on cleanup errors
-            pass
-
-        # Optional: Clean up file from container (best effort)
-        try:
-            if 'exec_path' in locals() and 'container_obj' in locals():
-                container_obj.exec_run(
-                    f"rm -f {exec_path}",
-                    user="sandbox"
-                )
-        except:
-            pass  # Best effort cleanup

cortex/autonomy/tools/executors/search_providers/__init__.py

@@ -1,13 +0,0 @@
-"""Web search provider implementations."""
-
-from .base import SearchProvider, SearchResult, SearchResponse
-from .brave import BraveSearchProvider
-from .duckduckgo import DuckDuckGoProvider
-
-__all__ = [
-    "SearchProvider",
-    "SearchResult",
-    "SearchResponse",
-    "BraveSearchProvider",
-    "DuckDuckGoProvider",
-]

cortex/autonomy/tools/executors/search_providers/base.py

@@ -1,49 +0,0 @@
-"""Base interface for web search providers."""
-
-from abc import ABC, abstractmethod
-from typing import List, Optional
-from dataclasses import dataclass
-
-
-@dataclass
-class SearchResult:
-    """Standardized search result format."""
-    title: str
-    url: str
-    snippet: str
-    score: Optional[float] = None
-
-
-@dataclass
-class SearchResponse:
-    """Standardized search response."""
-    results: List[SearchResult]
-    count: int
-    provider: str
-    query: str
-    error: Optional[str] = None
-
-
-class SearchProvider(ABC):
-    """Abstract base class for search providers."""
-
-    @abstractmethod
-    async def search(
-        self,
-        query: str,
-        max_results: int = 5,
-        **kwargs
-    ) -> SearchResponse:
-        """Execute search and return standardized results."""
-        pass
-
-    @abstractmethod
-    async def health_check(self) -> bool:
-        """Check if provider is healthy and reachable."""
-        pass
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """Provider name."""
-        pass

cortex/autonomy/tools/executors/search_providers/brave.py

@@ -1,123 +0,0 @@
-"""Brave Search API provider implementation."""
-
-import os
-import asyncio
-import aiohttp
-from .base import SearchProvider, SearchResponse, SearchResult
-from ..utils.resilience import async_retry
-
-
-class BraveSearchProvider(SearchProvider):
-    """Brave Search API implementation."""
-
-    def __init__(self):
-        self.api_key = os.getenv("BRAVE_SEARCH_API_KEY", "")
-        self.base_url = os.getenv(
-            "BRAVE_SEARCH_URL",
-            "https://api.search.brave.com/res/v1"
-        )
-        self.timeout = float(os.getenv("BRAVE_SEARCH_TIMEOUT", "10.0"))
-
-    @property
-    def name(self) -> str:
-        return "brave"
-
-    @async_retry(
-        max_attempts=3,
-        exceptions=(aiohttp.ClientError, asyncio.TimeoutError)
-    )
-    async def search(
-        self,
-        query: str,
-        max_results: int = 5,
-        **kwargs
-    ) -> SearchResponse:
-        """Execute Brave search with retry logic."""
-
-        if not self.api_key:
-            return SearchResponse(
-                results=[],
-                count=0,
-                provider=self.name,
-                query=query,
-                error="BRAVE_SEARCH_API_KEY not configured"
-            )
-
-        headers = {
-            "Accept": "application/json",
-            "X-Subscription-Token": self.api_key
-        }
-
-        params = {
-            "q": query,
-            "count": min(max_results, 20)  # Brave max is 20
-        }
-
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(
-                    f"{self.base_url}/web/search",
-                    headers=headers,
-                    params=params,
-                    timeout=aiohttp.ClientTimeout(total=self.timeout)
-                ) as resp:
-                    if resp.status == 200:
-                        data = await resp.json()
-                        results = []
-
-                        for item in data.get("web", {}).get("results", []):
-                            results.append(SearchResult(
-                                title=item.get("title", ""),
-                                url=item.get("url", ""),
-                                snippet=item.get("description", ""),
-                                score=item.get("score")
-                            ))
-
-                        return SearchResponse(
-                            results=results,
-                            count=len(results),
-                            provider=self.name,
-                            query=query
-                        )
-                    elif resp.status == 401:
-                        error = "Authentication failed. Check BRAVE_SEARCH_API_KEY"
-                    elif resp.status == 429:
-                        error = f"Rate limit exceeded. Status: {resp.status}"
-                    else:
-                        error_text = await resp.text()
-                        error = f"HTTP {resp.status}: {error_text}"
-
-                    return SearchResponse(
-                        results=[],
-                        count=0,
-                        provider=self.name,
-                        query=query,
-                        error=error
-                    )
-
-        except aiohttp.ClientConnectorError as e:
-            return SearchResponse(
-                results=[],
-                count=0,
-                provider=self.name,
-                query=query,
-                error=f"Cannot connect to Brave Search API: {str(e)}"
-            )
-        except asyncio.TimeoutError:
-            return SearchResponse(
-                results=[],
-                count=0,
-                provider=self.name,
-                query=query,
-                error=f"Search timeout after {self.timeout}s"
-            )
-
-    async def health_check(self) -> bool:
-        """Check if Brave API is reachable."""
-        if not self.api_key:
-            return False
-        try:
-            response = await self.search("test", max_results=1)
-            return response.error is None
-        except:
-            return False

cortex/autonomy/tools/executors/search_providers/duckduckgo.py

@@ -1,60 +0,0 @@
-"""DuckDuckGo search provider with retry logic (legacy fallback)."""
-
-from duckduckgo_search import DDGS
-from .base import SearchProvider, SearchResponse, SearchResult
-from ..utils.resilience import async_retry
-
-
-class DuckDuckGoProvider(SearchProvider):
-    """DuckDuckGo search implementation with retry logic."""
-
-    @property
-    def name(self) -> str:
-        return "duckduckgo"
-
-    @async_retry(
-        max_attempts=3,
-        exceptions=(Exception,)  # DDG throws generic exceptions
-    )
-    async def search(
-        self,
-        query: str,
-        max_results: int = 5,
-        **kwargs
-    ) -> SearchResponse:
-        """Execute DuckDuckGo search with retry logic."""
-
-        try:
-            with DDGS() as ddgs:
-                results = []
-
-                for result in ddgs.text(query, max_results=max_results):
-                    results.append(SearchResult(
-                        title=result.get("title", ""),
-                        url=result.get("href", ""),
-                        snippet=result.get("body", "")
-                    ))
-
-                return SearchResponse(
-                    results=results,
-                    count=len(results),
-                    provider=self.name,
-                    query=query
-                )
-
-        except Exception as e:
-            return SearchResponse(
-                results=[],
-                count=0,
-                provider=self.name,
-                query=query,
-                error=f"Search failed: {str(e)}"
-            )
-
-    async def health_check(self) -> bool:
-        """Basic health check for DDG."""
-        try:
-            response = await self.search("test", max_results=1)
-            return response.error is None
-        except:
-            return False

cortex/autonomy/tools/executors/trilium.py

@@ -1,216 +0,0 @@
-"""
-Trilium notes executor for searching and creating notes via ETAPI.
-
-This module provides integration with Trilium notes through the ETAPI HTTP API
-with improved resilience: timeout configuration, retry logic, and connection pooling.
-"""
-
-import os
-import asyncio
-import aiohttp
-from typing import Dict, Optional
-from ..utils.resilience import async_retry
-
-
-TRILIUM_URL = os.getenv("TRILIUM_URL", "http://localhost:8080")
-TRILIUM_TOKEN = os.getenv("TRILIUM_ETAPI_TOKEN", "")
-
-# Module-level session for connection pooling
-_session: Optional[aiohttp.ClientSession] = None
-
-
-def get_session() -> aiohttp.ClientSession:
-    """Get or create shared aiohttp session for connection pooling."""
-    global _session
-    if _session is None or _session.closed:
-        timeout = aiohttp.ClientTimeout(
-            total=float(os.getenv("TRILIUM_TIMEOUT", "30.0")),
-            connect=float(os.getenv("TRILIUM_CONNECT_TIMEOUT", "10.0"))
-        )
-        _session = aiohttp.ClientSession(timeout=timeout)
-    return _session
-
-
-@async_retry(
-    max_attempts=3,
-    exceptions=(aiohttp.ClientError, asyncio.TimeoutError)
-)
-async def search_notes(args: Dict) -> Dict:
-    """Search Trilium notes via ETAPI with retry logic.
-
-    Args:
-        args: Dictionary containing:
-            - query (str): Search query
-            - limit (int, optional): Maximum notes to return (default: 5, max: 20)
-
-    Returns:
-        dict: Search results containing:
-            - notes (list): List of notes with noteId, title, content, type
-            - count (int): Number of notes returned
-            OR
-            - error (str): Error message if search failed
-    """
-    query = args.get("query")
-    limit = args.get("limit", 5)
-
-    # Validation
-    if not query:
-        return {"error": "No query provided"}
-
-    if not TRILIUM_TOKEN:
-        return {
-            "error": "TRILIUM_ETAPI_TOKEN not configured in environment",
-            "hint": "Set TRILIUM_ETAPI_TOKEN in .env file"
-        }
-
-    # Cap limit
-    limit = min(max(limit, 1), 20)
-
-    try:
-        session = get_session()
-        async with session.get(
-            f"{TRILIUM_URL}/etapi/notes",
-            params={"search": query, "limit": limit},
-            headers={"Authorization": TRILIUM_TOKEN}
-        ) as resp:
-            if resp.status == 200:
-                data = await resp.json()
-                # ETAPI returns {"results": [...]} format
-                results = data.get("results", [])
-                return {
-                    "notes": results,
-                    "count": len(results)
-                }
-            elif resp.status == 401:
-                return {
-                    "error": "Authentication failed. Check TRILIUM_ETAPI_TOKEN",
-                    "status": 401
-                }
-            elif resp.status == 404:
-                return {
-                    "error": "Trilium API endpoint not found. Check TRILIUM_URL",
-                    "status": 404,
-                    "url": TRILIUM_URL
-                }
-            else:
-                error_text = await resp.text()
-                return {
-                    "error": f"HTTP {resp.status}: {error_text}",
-                    "status": resp.status
-                }
-
-    except aiohttp.ClientConnectorError as e:
-        return {
-            "error": f"Cannot connect to Trilium at {TRILIUM_URL}",
-            "hint": "Check if Trilium is running and URL is correct",
-            "details": str(e)
-        }
-    except asyncio.TimeoutError:
-        timeout = os.getenv("TRILIUM_TIMEOUT", "30.0")
-        return {
-            "error": f"Trilium request timeout after {timeout}s",
-            "hint": "Trilium may be slow or unresponsive"
-        }
-    except Exception as e:
-        return {
-            "error": f"Search failed: {str(e)}",
-            "type": type(e).__name__
-        }
-
-
-@async_retry(
-    max_attempts=3,
-    exceptions=(aiohttp.ClientError, asyncio.TimeoutError)
-)
-async def create_note(args: Dict) -> Dict:
-    """Create a note in Trilium via ETAPI with retry logic.
-
-    Args:
-        args: Dictionary containing:
-            - title (str): Note title
-            - content (str): Note content in markdown or HTML
-            - parent_note_id (str, optional): Parent note ID to nest under
-
-    Returns:
-        dict: Creation result containing:
-            - noteId (str): ID of created note
-            - title (str): Title of created note
-            - success (bool): True if created successfully
-            OR
-            - error (str): Error message if creation failed
-    """
-    title = args.get("title")
-    content = args.get("content")
-    parent_note_id = args.get("parent_note_id", "root")  # Default to root if not specified
-
-    # Validation
-    if not title:
-        return {"error": "No title provided"}
-
-    if not content:
-        return {"error": "No content provided"}
-
-    if not TRILIUM_TOKEN:
-        return {
-            "error": "TRILIUM_ETAPI_TOKEN not configured in environment",
-            "hint": "Set TRILIUM_ETAPI_TOKEN in .env file"
-        }
-
-    # Prepare payload
-    payload = {
-        "parentNoteId": parent_note_id,  # Always include parentNoteId
-        "title": title,
-        "content": content,
-        "type": "text",
-        "mime": "text/html"
-    }
-
-    try:
-        session = get_session()
-        async with session.post(
-            f"{TRILIUM_URL}/etapi/create-note",
-            json=payload,
-            headers={"Authorization": TRILIUM_TOKEN}
-        ) as resp:
-            if resp.status in [200, 201]:
-                data = await resp.json()
-                return {
-                    "noteId": data.get("noteId"),
-                    "title": title,
-                    "success": True
-                }
-            elif resp.status == 401:
-                return {
-                    "error": "Authentication failed. Check TRILIUM_ETAPI_TOKEN",
-                    "status": 401
-                }
-            elif resp.status == 404:
-                return {
-                    "error": "Trilium API endpoint not found. Check TRILIUM_URL",
-                    "status": 404,
-                    "url": TRILIUM_URL
-                }
-            else:
-                error_text = await resp.text()
-                return {
-                    "error": f"HTTP {resp.status}: {error_text}",
-                    "status": resp.status
-                }
-
-    except aiohttp.ClientConnectorError as e:
-        return {
-            "error": f"Cannot connect to Trilium at {TRILIUM_URL}",
-            "hint": "Check if Trilium is running and URL is correct",
-            "details": str(e)
-        }
-    except asyncio.TimeoutError:
-        timeout = os.getenv("TRILIUM_TIMEOUT", "30.0")
-        return {
-            "error": f"Trilium request timeout after {timeout}s",
-            "hint": "Trilium may be slow or unresponsive"
-        }
-    except Exception as e:
-        return {
-            "error": f"Note creation failed: {str(e)}",
-            "type": type(e).__name__
-        }

cortex/autonomy/tools/executors/web_search.py

@@ -1,113 +0,0 @@
-"""
-Web search executor with pluggable provider support.
-
-Supports multiple providers with automatic fallback:
-- Brave Search API (recommended, configurable)
-- DuckDuckGo (legacy fallback)
-"""
-
-import os
-from typing import Dict, Optional
-from .search_providers.base import SearchProvider
-from .search_providers.brave import BraveSearchProvider
-from .search_providers.duckduckgo import DuckDuckGoProvider
-
-# Provider registry
-PROVIDERS = {
-    "brave": BraveSearchProvider,
-    "duckduckgo": DuckDuckGoProvider,
-}
-
-# Singleton provider instances
-_provider_instances: Dict[str, SearchProvider] = {}
-
-
-def get_provider(name: str) -> Optional[SearchProvider]:
-    """Get or create provider instance."""
-    if name not in _provider_instances:
-        provider_class = PROVIDERS.get(name)
-        if provider_class:
-            _provider_instances[name] = provider_class()
-    return _provider_instances.get(name)
-
-
-async def search_web(args: Dict) -> Dict:
-    """Search the web using configured provider with automatic fallback.
-
-    Args:
-        args: Dictionary containing:
-            - query (str): The search query
-            - max_results (int, optional): Maximum results to return (default: 5, max: 20)
-            - provider (str, optional): Force specific provider
-
-    Returns:
-        dict: Search results containing:
-            - results (list): List of search results with title, url, snippet
-            - count (int): Number of results returned
-            - provider (str): Provider that returned results
-            OR
-            - error (str): Error message if all providers failed
-    """
-    query = args.get("query")
-    max_results = args.get("max_results", 5)
-    forced_provider = args.get("provider")
-
-    # Validation
-    if not query:
-        return {"error": "No query provided"}
-
-    # Cap max_results
-    max_results = min(max(max_results, 1), 20)
-
-    # Get provider preference from environment
-    primary_provider = os.getenv("WEB_SEARCH_PROVIDER", "duckduckgo")
-    fallback_providers = os.getenv(
-        "WEB_SEARCH_FALLBACK",
-        "duckduckgo"
-    ).split(",")
-
-    # Build provider list
-    if forced_provider:
-        providers_to_try = [forced_provider]
-    else:
-        providers_to_try = [primary_provider] + [
-            p.strip() for p in fallback_providers if p.strip() != primary_provider
-        ]
-
-    # Try providers in order
-    last_error = None
-    for provider_name in providers_to_try:
-        provider = get_provider(provider_name)
-        if not provider:
-            last_error = f"Unknown provider: {provider_name}"
-            continue
-
-        try:
-            response = await provider.search(query, max_results)
-
-            # If successful, return results
-            if response.error is None and response.count > 0:
-                return {
-                    "results": [
-                        {
-                            "title": r.title,
-                            "url": r.url,
-                            "snippet": r.snippet,
-                        }
-                        for r in response.results
-                    ],
-                    "count": response.count,
-                    "provider": provider_name
-                }
-
-            last_error = response.error or "No results returned"
-
-        except Exception as e:
-            last_error = f"{provider_name} failed: {str(e)}"
-            continue
-
-    # All providers failed
-    return {
-        "error": f"All search providers failed. Last error: {last_error}",
-        "providers_tried": providers_to_try
-    }

cortex/autonomy/tools/function_caller.py

@@ -1,235 +0,0 @@
-"""
-Provider-agnostic function caller with iterative tool calling loop.
-
-This module implements the iterative loop that allows LLMs to call tools
-multiple times until they have the information they need to answer the user.
-"""
-
-import os
-import logging
-from typing import Dict, List, Optional
-from llm.llm_router import call_llm, TOOL_ADAPTERS, BACKENDS
-from .registry import get_registry
-from .stream_events import get_stream_manager
-
-
-logger = logging.getLogger(__name__)
-
-
-class FunctionCaller:
-    """Provider-agnostic iterative tool calling loop.
-
-    This class orchestrates the back-and-forth between the LLM and tools:
-    1. Call LLM with tools available
-    2. If LLM requests tool calls, execute them
-    3. Add results to conversation
-    4. Repeat until LLM is done or max iterations reached
-    """
-
-    def __init__(self, backend: str, temperature: float = 0.7):
-        """Initialize function caller.
-
-        Args:
-            backend: LLM backend to use ("OPENAI", "OLLAMA", etc.)
-            temperature: Temperature for LLM calls
-        """
-        self.backend = backend
-        self.temperature = temperature
-        self.registry = get_registry()
-        self.max_iterations = int(os.getenv("MAX_TOOL_ITERATIONS", "5"))
-
-        # Resolve adapter for this backend
-        self.adapter = self._get_adapter()
-
-    def _get_adapter(self):
-        """Get the appropriate adapter for this backend."""
-        adapter = TOOL_ADAPTERS.get(self.backend)
-
-        # For PRIMARY/SECONDARY/FALLBACK, determine adapter based on provider
-        if adapter is None and self.backend in ["PRIMARY", "SECONDARY", "FALLBACK"]:
-            cfg = BACKENDS.get(self.backend, {})
-            provider = cfg.get("provider", "").lower()
-
-            if provider == "openai":
-                adapter = TOOL_ADAPTERS["OPENAI"]
-            elif provider == "ollama":
-                adapter = TOOL_ADAPTERS["OLLAMA"]
-            elif provider == "mi50":
-                adapter = TOOL_ADAPTERS["MI50"]
-
-        return adapter
-
-    async def call_with_tools(
-        self,
-        messages: List[Dict],
-        max_tokens: int = 2048,
-        session_id: Optional[str] = None
-    ) -> Dict:
-        """Execute LLM with iterative tool calling.
-
-        Args:
-            messages: Conversation history
-            max_tokens: Maximum tokens for LLM response
-            session_id: Optional session ID for streaming events
-
-        Returns:
-            dict: {
-                "content": str,  # Final response
-                "iterations": int,  # Number of iterations
-                "tool_calls": list,  # All tool calls made
-                "messages": list,  # Full conversation history
-                "truncated": bool (optional)  # True if max iterations reached
-            }
-        """
-        logger.info(f"🔍 FunctionCaller.call_with_tools() invoked with {len(messages)} messages")
-        tools = self.registry.get_tool_definitions()
-        logger.info(f"🔍 Got {len(tools or [])} tool definitions from registry")
-
-        # Get stream manager for emitting events
-        stream_manager = get_stream_manager()
-        should_stream = session_id and stream_manager.has_subscribers(session_id)
-
-        # If no tools are enabled, just call LLM directly
-        if not tools:
-            logger.warning("FunctionCaller invoked but no tools are enabled")
-            response = await call_llm(
-                messages=messages,
-                backend=self.backend,
-                temperature=self.temperature,
-                max_tokens=max_tokens
-            )
-            return {
-                "content": response,
-                "iterations": 1,
-                "tool_calls": [],
-                "messages": messages + [{"role": "assistant", "content": response}]
-            }
-
-        conversation = messages.copy()
-        all_tool_calls = []
-
-        for iteration in range(self.max_iterations):
-            logger.info(f"Tool calling iteration {iteration + 1}/{self.max_iterations}")
-
-            # Emit thinking event
-            if should_stream:
-                await stream_manager.emit(session_id, "thinking", {
-                    "message": f"🤔 Thinking... (iteration {iteration + 1}/{self.max_iterations})"
-                })
-
-            # Call LLM with tools
-            try:
-                response = await call_llm(
-                    messages=conversation,
-                    backend=self.backend,
-                    temperature=self.temperature,
-                    max_tokens=max_tokens,
-                    tools=tools,
-                    tool_choice="auto",
-                    return_adapter_response=True
-                )
-            except Exception as e:
-                logger.error(f"LLM call failed: {str(e)}")
-                if should_stream:
-                    await stream_manager.emit(session_id, "error", {
-                        "message": f"❌ Error: {str(e)}"
-                    })
-                return {
-                    "content": f"Error calling LLM: {str(e)}",
-                    "iterations": iteration + 1,
-                    "tool_calls": all_tool_calls,
-                    "messages": conversation,
-                    "error": True
-                }
-
-            # Add assistant message to conversation
-            if response.get("content"):
-                conversation.append({
-                    "role": "assistant",
-                    "content": response["content"]
-                })
-
-            # Check for tool calls
-            tool_calls = response.get("tool_calls")
-            logger.debug(f"Response from LLM: content_length={len(response.get('content', ''))}, tool_calls={tool_calls}")
-            if not tool_calls:
-                # No more tool calls - LLM is done
-                logger.info(f"Tool calling complete after {iteration + 1} iterations")
-                if should_stream:
-                    await stream_manager.emit(session_id, "done", {
-                        "message": "✅ Complete!",
-                        "final_answer": response["content"]
-                    })
-                return {
-                    "content": response["content"],
-                    "iterations": iteration + 1,
-                    "tool_calls": all_tool_calls,
-                    "messages": conversation
-                }
-
-            # Execute each tool call
-            logger.info(f"Executing {len(tool_calls)} tool call(s)")
-            for tool_call in tool_calls:
-                all_tool_calls.append(tool_call)
-
-                tool_name = tool_call.get("name")
-                tool_args = tool_call.get("arguments", {})
-                tool_id = tool_call.get("id", "unknown")
-
-                logger.info(f"Calling tool: {tool_name} with args: {tool_args}")
-
-                # Emit tool call event
-                if should_stream:
-                    await stream_manager.emit(session_id, "tool_call", {
-                        "tool": tool_name,
-                        "args": tool_args,
-                        "message": f"🔧 Using tool: {tool_name}"
-                    })
-
-                try:
-                    # Execute tool
-                    result = await self.registry.execute_tool(tool_name, tool_args)
-                    logger.info(f"Tool {tool_name} executed successfully")
-
-                    # Emit tool result event
-                    if should_stream:
-                        # Format result preview
-                        result_preview = str(result)
-                        if len(result_preview) > 200:
-                            result_preview = result_preview[:200] + "..."
-
-                        await stream_manager.emit(session_id, "tool_result", {
-                            "tool": tool_name,
-                            "result": result,
-                            "message": f"📊 Result: {result_preview}"
-                        })
-
-                except Exception as e:
-                    logger.error(f"Tool {tool_name} execution failed: {str(e)}")
-                    result = {"error": f"Tool execution failed: {str(e)}"}
-
-                # Format result using adapter
-                if not self.adapter:
-                    logger.warning(f"No adapter available for backend {self.backend}, using fallback format")
-                    result_msg = {
-                        "role": "user",
-                        "content": f"Tool {tool_name} result: {result}"
-                    }
-                else:
-                    result_msg = self.adapter.format_tool_result(
-                        tool_id,
-                        tool_name,
-                        result
-                    )
-
-                conversation.append(result_msg)
-
-        # Max iterations reached without completion
-        logger.warning(f"Tool calling truncated after {self.max_iterations} iterations")
-        return {
-            "content": response.get("content", ""),
-            "iterations": self.max_iterations,
-            "tool_calls": all_tool_calls,
-            "messages": conversation,
-            "truncated": True
-        }

cortex/autonomy/tools/orchestrator.py

@@ -1,357 +0,0 @@
-"""
-Tool Orchestrator - executes autonomous tool invocations asynchronously.
-"""
-
-import asyncio
-import logging
-from typing import Dict, List, Any, Optional
-import os
-
-logger = logging.getLogger(__name__)
-
-
-class ToolOrchestrator:
-    """Orchestrates async tool execution and result aggregation."""
-
-    def __init__(self, tool_timeout: int = 30):
-        """
-        Initialize orchestrator.
-
-        Args:
-            tool_timeout: Max seconds per tool call (default 30)
-        """
-        self.tool_timeout = tool_timeout
-        self.available_tools = self._discover_tools()
-
-    def _discover_tools(self) -> Dict[str, Any]:
-        """Discover available tool modules."""
-        tools = {}
-
-        # Import tool modules as they become available
-        if os.getenv("NEOMEM_ENABLED", "false").lower() == "true":
-            try:
-                from memory.neomem_client import search_neomem
-                tools["RAG"] = search_neomem
-                logger.debug("[ORCHESTRATOR] RAG tool available")
-            except ImportError:
-                logger.debug("[ORCHESTRATOR] RAG tool not available")
-        else:
-            logger.info("[ORCHESTRATOR] NEOMEM_ENABLED is false; RAG tool disabled")
-
-        try:
-            from integrations.web_search import web_search
-            tools["WEB"] = web_search
-            logger.debug("[ORCHESTRATOR] WEB tool available")
-        except ImportError:
-            logger.debug("[ORCHESTRATOR] WEB tool not available")
-
-        try:
-            from integrations.weather import get_weather
-            tools["WEATHER"] = get_weather
-            logger.debug("[ORCHESTRATOR] WEATHER tool available")
-        except ImportError:
-            logger.debug("[ORCHESTRATOR] WEATHER tool not available")
-
-        try:
-            from integrations.codebrain import query_codebrain
-            tools["CODEBRAIN"] = query_codebrain
-            logger.debug("[ORCHESTRATOR] CODEBRAIN tool available")
-        except ImportError:
-            logger.debug("[ORCHESTRATOR] CODEBRAIN tool not available")
-
-        return tools
-
-    async def execute_tools(
-        self,
-        tools_to_invoke: List[Dict[str, Any]],
-        context_state: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Execute multiple tools asynchronously.
-
-        Args:
-            tools_to_invoke: List of tool specs from decision engine
-                [{"tool": "RAG", "query": "...", "reason": "...", "priority": 0.9}, ...]
-            context_state: Full context for tool execution
-
-        Returns:
-            {
-                "results": {
-                    "RAG": {...},
-                    "WEB": {...},
-                    ...
-                },
-                "execution_summary": {
-                    "tools_invoked": ["RAG", "WEB"],
-                    "successful": ["RAG"],
-                    "failed": ["WEB"],
-                    "total_time_ms": 1234
-                }
-            }
-        """
-        import time
-        start_time = time.time()
-
-        logger.info(f"[ORCHESTRATOR] Executing {len(tools_to_invoke)} tools asynchronously")
-
-        # Create tasks for each tool
-        tasks = []
-        tool_names = []
-
-        for tool_spec in tools_to_invoke:
-            tool_name = tool_spec["tool"]
-            query = tool_spec["query"]
-
-            if tool_name in self.available_tools:
-                task = self._execute_single_tool(tool_name, query, context_state)
-                tasks.append(task)
-                tool_names.append(tool_name)
-                logger.debug(f"[ORCHESTRATOR] Queued {tool_name}: {query[:50]}...")
-            else:
-                logger.warning(f"[ORCHESTRATOR] Tool {tool_name} not available, skipping")
-
-        # Execute all tools concurrently with timeout
-        results = {}
-        successful = []
-        failed = []
-
-        if tasks:
-            try:
-                # Wait for all tasks with global timeout
-                completed = await asyncio.wait_for(
-                    asyncio.gather(*tasks, return_exceptions=True),
-                    timeout=self.tool_timeout
-                )
-
-                # Process results
-                for tool_name, result in zip(tool_names, completed):
-                    if isinstance(result, Exception):
-                        logger.error(f"[ORCHESTRATOR] {tool_name} failed: {result}")
-                        results[tool_name] = {"error": str(result), "success": False}
-                        failed.append(tool_name)
-                    else:
-                        logger.info(f"[ORCHESTRATOR] {tool_name} completed successfully")
-                        results[tool_name] = result
-                        successful.append(tool_name)
-
-            except asyncio.TimeoutError:
-                logger.error(f"[ORCHESTRATOR] Global timeout ({self.tool_timeout}s) exceeded")
-                for tool_name in tool_names:
-                    if tool_name not in results:
-                        results[tool_name] = {"error": "timeout", "success": False}
-                        failed.append(tool_name)
-
-        end_time = time.time()
-        total_time_ms = int((end_time - start_time) * 1000)
-
-        execution_summary = {
-            "tools_invoked": tool_names,
-            "successful": successful,
-            "failed": failed,
-            "total_time_ms": total_time_ms
-        }
-
-        logger.info(f"[ORCHESTRATOR] Execution complete: {len(successful)}/{len(tool_names)} successful in {total_time_ms}ms")
-
-        return {
-            "results": results,
-            "execution_summary": execution_summary
-        }
-
-    async def _execute_single_tool(
-        self,
-        tool_name: str,
-        query: str,
-        context_state: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Execute a single tool with error handling.
-
-        Args:
-            tool_name: Name of tool (RAG, WEB, etc.)
-            query: Query string for the tool
-            context_state: Context for tool execution
-
-        Returns:
-            Tool-specific result dict
-        """
-        tool_func = self.available_tools.get(tool_name)
-        if not tool_func:
-            raise ValueError(f"Tool {tool_name} not available")
-
-        try:
-            logger.debug(f"[ORCHESTRATOR] Invoking {tool_name}...")
-
-            # Different tools have different signatures - adapt as needed
-            if tool_name == "RAG":
-                result = await self._invoke_rag(tool_func, query, context_state)
-            elif tool_name == "WEB":
-                result = await self._invoke_web(tool_func, query)
-            elif tool_name == "WEATHER":
-                result = await self._invoke_weather(tool_func, query)
-            elif tool_name == "CODEBRAIN":
-                result = await self._invoke_codebrain(tool_func, query, context_state)
-            else:
-                # Generic invocation
-                result = await tool_func(query)
-
-            return {
-                "success": True,
-                "tool": tool_name,
-                "query": query,
-                "data": result
-            }
-
-        except Exception as e:
-            logger.error(f"[ORCHESTRATOR] {tool_name} execution failed: {e}")
-            raise
-
-    async def _invoke_rag(self, func, query: str, context: Dict[str, Any]) -> Any:
-        """Invoke RAG tool (NeoMem search)."""
-        session_id = context.get("session_id", "unknown")
-        # RAG searches memory for relevant past interactions
-        try:
-            results = await func(query, limit=5, session_id=session_id)
-            return results
-        except Exception as e:
-            logger.warning(f"[ORCHESTRATOR] RAG invocation failed, returning empty: {e}")
-            return []
-
-    async def _invoke_web(self, func, query: str) -> Any:
-        """Invoke web search tool."""
-        try:
-            results = await func(query, max_results=5)
-            return results
-        except Exception as e:
-            logger.warning(f"[ORCHESTRATOR] WEB invocation failed: {e}")
-            return {"error": str(e), "results": []}
-
-    async def _invoke_weather(self, func, query: str) -> Any:
-        """Invoke weather tool."""
-        # Extract location from query (simple heuristic)
-        # In future: use LLM to extract location
-        try:
-            location = self._extract_location(query)
-            results = await func(location)
-            return results
-        except Exception as e:
-            logger.warning(f"[ORCHESTRATOR] WEATHER invocation failed: {e}")
-            return {"error": str(e)}
-
-    async def _invoke_codebrain(self, func, query: str, context: Dict[str, Any]) -> Any:
-        """Invoke codebrain tool."""
-        try:
-            results = await func(query, context=context)
-            return results
-        except Exception as e:
-            logger.warning(f"[ORCHESTRATOR] CODEBRAIN invocation failed: {e}")
-            return {"error": str(e)}
-
-    def _extract_location(self, query: str) -> str:
-        """
-        Extract location from weather query.
-        Simple heuristic - in future use LLM.
-        """
-        # Common location indicators
-        indicators = ["in ", "at ", "for ", "weather in ", "temperature in "]
-
-        query_lower = query.lower()
-        for indicator in indicators:
-            if indicator in query_lower:
-                # Get text after indicator
-                parts = query_lower.split(indicator, 1)
-                if len(parts) > 1:
-                    location = parts[1].strip().split()[0]  # First word after indicator
-                    return location
-
-        # Default fallback
-        return "current location"
-
-    def format_results_for_context(self, orchestrator_result: Dict[str, Any]) -> str:
-        """
-        Format tool results for inclusion in context/prompt.
-
-        Args:
-            orchestrator_result: Output from execute_tools()
-
-        Returns:
-            Formatted string for prompt injection
-        """
-        results = orchestrator_result.get("results", {})
-        summary = orchestrator_result.get("execution_summary", {})
-
-        if not results:
-            return ""
-
-        formatted = "\n=== AUTONOMOUS TOOL RESULTS ===\n"
-
-        for tool_name, tool_result in results.items():
-            if tool_result.get("success", False):
-                formatted += f"\n[{tool_name}]\n"
-                data = tool_result.get("data", {})
-
-                # Format based on tool type
-                if tool_name == "RAG":
-                    formatted += self._format_rag_results(data)
-                elif tool_name == "WEB":
-                    formatted += self._format_web_results(data)
-                elif tool_name == "WEATHER":
-                    formatted += self._format_weather_results(data)
-                elif tool_name == "CODEBRAIN":
-                    formatted += self._format_codebrain_results(data)
-                else:
-                    formatted += f"{data}\n"
-            else:
-                formatted += f"\n[{tool_name}] - Failed: {tool_result.get('error', 'unknown')}\n"
-
-        formatted += f"\n(Tools executed in {summary.get('total_time_ms', 0)}ms)\n"
-        formatted += "=" * 40 + "\n"
-
-        return formatted
-
-    def _format_rag_results(self, data: Any) -> str:
-        """Format RAG/memory search results."""
-        if not data:
-            return "No relevant memories found.\n"
-
-        formatted = "Relevant memories:\n"
-        for i, item in enumerate(data[:3], 1):  # Top 3
-            text = item.get("text", item.get("content", str(item)))
-            formatted += f"  {i}. {text[:100]}...\n"
-        return formatted
-
-    def _format_web_results(self, data: Any) -> str:
-        """Format web search results."""
-        if isinstance(data, dict) and data.get("error"):
-            return f"Web search failed: {data['error']}\n"
-
-        results = data.get("results", []) if isinstance(data, dict) else data
-        if not results:
-            return "No web results found.\n"
-
-        formatted = "Web search results:\n"
-        for i, item in enumerate(results[:3], 1):  # Top 3
-            title = item.get("title", "No title")
-            snippet = item.get("snippet", item.get("description", ""))
-            formatted += f"  {i}. {title}\n     {snippet[:100]}...\n"
-        return formatted
-
-    def _format_weather_results(self, data: Any) -> str:
-        """Format weather results."""
-        if isinstance(data, dict) and data.get("error"):
-            return f"Weather lookup failed: {data['error']}\n"
-
-        # Assuming weather API returns temp, conditions, etc.
-        temp = data.get("temperature", "unknown")
-        conditions = data.get("conditions", "unknown")
-        location = data.get("location", "requested location")
-
-        return f"Weather for {location}: {temp}, {conditions}\n"
-
-    def _format_codebrain_results(self, data: Any) -> str:
-        """Format codebrain results."""
-        if isinstance(data, dict) and data.get("error"):
-            return f"Codebrain failed: {data['error']}\n"
-
-        # Format code-related results
-        return f"{data}\n"

cortex/autonomy/tools/registry.py

@@ -1,196 +0,0 @@
-"""
-Provider-agnostic Tool Registry for Lyra.
-
-This module provides a central registry for all available tools with
-Lyra-native definitions (not provider-specific).
-"""
-
-import os
-from typing import Dict, List, Optional
-from .executors import execute_code, search_web, search_notes, create_note
-
-
-class ToolRegistry:
-    """Registry for managing available tools and their definitions.
-
-    Tools are defined in Lyra's own format (provider-agnostic), and
-    adapters convert them to provider-specific formats (OpenAI function
-    calling, Ollama XML prompts, etc.).
-    """
-
-    def __init__(self):
-        """Initialize the tool registry with feature flags from environment."""
-        self.tools = {}
-        self.executors = {}
-
-        # Feature flags from environment
-        self.code_execution_enabled = os.getenv("ENABLE_CODE_EXECUTION", "true").lower() == "true"
-        self.web_search_enabled = os.getenv("ENABLE_WEB_SEARCH", "true").lower() == "true"
-        self.trilium_enabled = os.getenv("ENABLE_TRILIUM", "false").lower() == "true"
-
-        self._register_tools()
-        self._register_executors()
-
-    def _register_executors(self):
-        """Register executor functions for each tool."""
-        if self.code_execution_enabled:
-            self.executors["execute_code"] = execute_code
-
-        if self.web_search_enabled:
-            self.executors["search_web"] = search_web
-
-        if self.trilium_enabled:
-            self.executors["search_notes"] = search_notes
-            self.executors["create_note"] = create_note
-
-    def _register_tools(self):
-        """Register all available tools based on feature flags."""
-
-        if self.code_execution_enabled:
-            self.tools["execute_code"] = {
-                "name": "execute_code",
-                "description": "Execute Python or bash code in a secure sandbox environment. Use this to perform calculations, data processing, file operations, or any programmatic tasks. The sandbox is persistent across calls within a session and has common Python packages (numpy, pandas, requests, matplotlib, scipy) pre-installed.",
-                "parameters": {
-                    "language": {
-                        "type": "string",
-                        "enum": ["python", "bash"],
-                        "description": "The programming language to execute (python or bash)"
-                    },
-                    "code": {
-                        "type": "string",
-                        "description": "The code to execute. For multi-line code, use proper indentation. For Python, use standard Python 3.11 syntax."
-                    },
-                    "reason": {
-                        "type": "string",
-                        "description": "Brief explanation of why you're executing this code and what you expect to achieve"
-                    }
-                },
-                "required": ["language", "code", "reason"]
-            }
-
-        if self.web_search_enabled:
-            self.tools["search_web"] = {
-                "name": "search_web",
-                "description": "Search the internet using DuckDuckGo to find current information, facts, news, or answers to questions. Returns a list of search results with titles, snippets, and URLs. Use this when you need up-to-date information or facts not in your training data.",
-                "parameters": {
-                    "query": {
-                        "type": "string",
-                        "description": "The search query to look up on the internet"
-                    },
-                    "max_results": {
-                        "type": "integer",
-                        "description": "Maximum number of results to return (default: 5, max: 10)"
-                    }
-                },
-                "required": ["query"]
-            }
-
-        if self.trilium_enabled:
-            self.tools["search_notes"] = {
-                "name": "search_notes",
-                "description": "Search through Trilium notes to find relevant information. Use this to retrieve knowledge, context, or information previously stored in the user's notes.",
-                "parameters": {
-                    "query": {
-                        "type": "string",
-                        "description": "The search query to find matching notes"
-                    },
-                    "limit": {
-                        "type": "integer",
-                        "description": "Maximum number of notes to return (default: 5, max: 20)"
-                    }
-                },
-                "required": ["query"]
-            }
-
-            self.tools["create_note"] = {
-                "name": "create_note",
-                "description": "Create a new note in Trilium. Use this to store important information, insights, or knowledge for future reference. Notes are stored in the user's Trilium knowledge base.",
-                "parameters": {
-                    "title": {
-                        "type": "string",
-                        "description": "The title of the note"
-                    },
-                    "content": {
-                        "type": "string",
-                        "description": "The content of the note in markdown or HTML format"
-                    },
-                    "parent_note_id": {
-                        "type": "string",
-                        "description": "Optional ID of the parent note to nest this note under"
-                    }
-                },
-                "required": ["title", "content"]
-            }
-
-    def get_tool_definitions(self) -> Optional[List[Dict]]:
-        """Get list of all enabled tool definitions in Lyra format.
-
-        Returns:
-            list: List of tool definition dicts, or None if no tools enabled
-        """
-        if not self.tools:
-            return None
-        return list(self.tools.values())
-
-    def get_tool_names(self) -> List[str]:
-        """Get list of all enabled tool names.
-
-        Returns:
-            list: List of tool name strings
-        """
-        return list(self.tools.keys())
-
-    def is_tool_enabled(self, tool_name: str) -> bool:
-        """Check if a specific tool is enabled.
-
-        Args:
-            tool_name: Name of the tool to check
-
-        Returns:
-            bool: True if tool is enabled, False otherwise
-        """
-        return tool_name in self.tools
-
-    def register_executor(self, tool_name: str, executor_func):
-        """Register an executor function for a tool.
-
-        Args:
-            tool_name: Name of the tool
-            executor_func: Async function that executes the tool
-        """
-        self.executors[tool_name] = executor_func
-
-    async def execute_tool(self, name: str, arguments: dict) -> dict:
-        """Execute a tool by name.
-
-        Args:
-            name: Tool name
-            arguments: Tool arguments dict
-
-        Returns:
-            dict: Tool execution result
-        """
-        if name not in self.executors:
-            return {"error": f"Unknown tool: {name}"}
-
-        executor = self.executors[name]
-        try:
-            return await executor(arguments)
-        except Exception as e:
-            return {"error": f"Tool execution failed: {str(e)}"}
-
-
-# Global registry instance (singleton pattern)
-_registry = None
-
-
-def get_registry() -> ToolRegistry:
-    """Get the global ToolRegistry instance.
-
-    Returns:
-        ToolRegistry: The global registry instance
-    """
-    global _registry
-    if _registry is None:
-        _registry = ToolRegistry()
-    return _registry

cortex/autonomy/tools/stream_events.py

@@ -1,91 +0,0 @@
-"""
-Event streaming for tool calling "show your work" feature.
-
-This module manages Server-Sent Events (SSE) for broadcasting the internal
-thinking process during tool calling operations.
-"""
-
-import asyncio
-from typing import Dict, Optional
-from collections import defaultdict
-import json
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class ToolStreamManager:
-    """Manages SSE streams for tool calling events."""
-
-    def __init__(self):
-        # session_id -> list of queues (one per connected client)
-        self._subscribers: Dict[str, list] = defaultdict(list)
-
-    def subscribe(self, session_id: str) -> asyncio.Queue:
-        """Subscribe to events for a session.
-
-        Returns:
-            Queue that will receive events for this session
-        """
-        queue = asyncio.Queue()
-        self._subscribers[session_id].append(queue)
-        logger.info(f"New subscriber for session {session_id}, total: {len(self._subscribers[session_id])}")
-        return queue
-
-    def unsubscribe(self, session_id: str, queue: asyncio.Queue):
-        """Unsubscribe from events for a session."""
-        if session_id in self._subscribers:
-            try:
-                self._subscribers[session_id].remove(queue)
-                logger.info(f"Removed subscriber for session {session_id}, remaining: {len(self._subscribers[session_id])}")
-
-                # Clean up empty lists
-                if not self._subscribers[session_id]:
-                    del self._subscribers[session_id]
-            except ValueError:
-                pass
-
-    async def emit(self, session_id: str, event_type: str, data: dict):
-        """Emit an event to all subscribers of a session.
-
-        Args:
-            session_id: Session to emit to
-            event_type: Type of event (thinking, tool_call, tool_result, done)
-            data: Event data
-        """
-        if session_id not in self._subscribers:
-            return
-
-        event = {
-            "type": event_type,
-            "data": data
-        }
-
-        # Send to all subscribers
-        dead_queues = []
-        for queue in self._subscribers[session_id]:
-            try:
-                await queue.put(event)
-            except Exception as e:
-                logger.error(f"Failed to emit event to queue: {e}")
-                dead_queues.append(queue)
-
-        # Clean up dead queues
-        for queue in dead_queues:
-            self.unsubscribe(session_id, queue)
-
-    def has_subscribers(self, session_id: str) -> bool:
-        """Check if a session has any active subscribers."""
-        return session_id in self._subscribers and len(self._subscribers[session_id]) > 0
-
-
-# Global stream manager instance
-_stream_manager: Optional[ToolStreamManager] = None
-
-
-def get_stream_manager() -> ToolStreamManager:
-    """Get the global stream manager instance."""
-    global _stream_manager
-    if _stream_manager is None:
-        _stream_manager = ToolStreamManager()
-    return _stream_manager

cortex/autonomy/tools/utils/__init__.py

@@ -1,5 +0,0 @@
-"""Utility modules for tool executors."""
-
-from .resilience import async_retry, async_timeout_wrapper
-
-__all__ = ["async_retry", "async_timeout_wrapper"]

cortex/autonomy/tools/utils/resilience.py

@@ -1,70 +0,0 @@
-"""Common resilience utilities for tool executors."""
-
-import asyncio
-import functools
-import logging
-from typing import Optional, Callable, Any, TypeVar
-from tenacity import (
-    retry,
-    stop_after_attempt,
-    wait_exponential,
-    retry_if_exception_type,
-    before_sleep_log
-)
-
-logger = logging.getLogger(__name__)
-
-# Type variable for generic decorators
-T = TypeVar('T')
-
-
-def async_retry(
-    max_attempts: int = 3,
-    exceptions: tuple = (Exception,),
-    **kwargs
-):
-    """Async retry decorator with exponential backoff.
-
-    Args:
-        max_attempts: Maximum retry attempts
-        exceptions: Exception types to retry on
-        **kwargs: Additional tenacity configuration
-
-    Example:
-        @async_retry(max_attempts=3, exceptions=(aiohttp.ClientError,))
-        async def fetch_data():
-            ...
-    """
-    return retry(
-        stop=stop_after_attempt(max_attempts),
-        wait=wait_exponential(multiplier=1, min=1, max=10),
-        retry=retry_if_exception_type(exceptions),
-        reraise=True,
-        before_sleep=before_sleep_log(logger, logging.WARNING),
-        **kwargs
-    )
-
-
-async def async_timeout_wrapper(
-    coro: Callable[..., T],
-    timeout: float,
-    *args,
-    **kwargs
-) -> T:
-    """Wrap async function with timeout.
-
-    Args:
-        coro: Async function to wrap
-        timeout: Timeout in seconds
-        *args, **kwargs: Arguments for the function
-
-    Returns:
-        Result from the function
-
-    Raises:
-        asyncio.TimeoutError: If timeout exceeded
-
-    Example:
-        result = await async_timeout_wrapper(some_async_func, 5.0, arg1, arg2)
-    """
-    return await asyncio.wait_for(coro(*args, **kwargs), timeout=timeout)

cortex/data/self_state.json

@@ -1,20 +0,0 @@
-{
-  "mood": "neutral",
-  "energy": 0.8500000000000001,
-  "focus": "conversation",
-  "confidence": 0.7,
-  "curiosity": 1.0,
-  "last_updated": "2025-12-27T18:16:00.152499",
-  "interaction_count": 27,
-  "learning_queue": [],
-  "active_goals": [],
-  "preferences": {
-    "verbosity": "medium",
-    "formality": "casual",
-    "proactivity": 0.3
-  },
-  "metadata": {
-    "version": "1.0",
-    "created_at": "2025-12-14T03:28:49.364768"
-  }
-}

cortex/ingest/__init__.py

@@ -1 +0,0 @@
-# Ingest module - handles communication with Intake service

cortex/ingest/ingest_handler.py

@@ -1,33 +0,0 @@
-# ingest_handler.py
-import os
-import httpx
-
-NEOMEM_URL = os.getenv("NEOMEM_API", "http://nvgram-api:7077")
-
-async def handle_ingest(payload):
-    """
-    Pass user+assistant turns to NeoMem.
-    Minimal version. Does not process or annotate.
-    """
-    data = {
-        "messages": [],
-        "user_id": "brian"   # default for now
-    }
-
-    if payload.user:
-        data["messages"].append({"role": "user", "content": payload.user})
-
-    if payload.assistant:
-        data["messages"].append({"role": "assistant", "content": payload.assistant})
-
-    try:
-        async with httpx.AsyncClient() as client:
-            r = await client.post(
-                f"{NEOMEM_URL}/memories",
-                json=data,
-                timeout=5
-            )
-            if r.status_code != 200:
-                print(f"[Ingest] NeoMem returned {r.status_code}: {r.text}")
-    except Exception as e:
-        print(f"[Ingest] Failed to send to NeoMem: {e}")

cortex/ingest/intake_client.py

@@ -1,45 +0,0 @@
-# cortex/intake_client.py
-import os, httpx, logging
-from typing import Dict, Any, Optional
-
-logger = logging.getLogger(__name__)
-
-class IntakeClient:
-    """Handles short-term / episodic summaries from Intake service."""
-
-    def __init__(self):
-        self.base_url = os.getenv("INTAKE_API_URL", "http://intake:7080")
-
-    async def summarize_turn(self, session_id: str, user_msg: str, assistant_msg: Optional[str] = None) -> Dict[str, Any]:
-        """
-        DEPRECATED: Intake v0.2 removed the /summarize endpoint.
-        Use add_exchange() instead, which auto-summarizes in the background.
-        This method is kept for backwards compatibility but will fail.
-        """
-        payload = {
-            "session_id": session_id,
-            "turns": [{"role": "user", "content": user_msg}]
-        }
-        if assistant_msg:
-            payload["turns"].append({"role": "assistant", "content": assistant_msg})
-
-        async with httpx.AsyncClient(timeout=30) as client:
-            try:
-                r = await client.post(f"{self.base_url}/summarize", json=payload)
-                r.raise_for_status()
-                return r.json()
-            except Exception as e:
-                logger.warning(f"Intake summarize_turn failed (endpoint removed in v0.2): {e}")
-                return {}
-
-    async def get_context(self, session_id: str) -> str:
-        """Get summarized context for a session from Intake."""
-        async with httpx.AsyncClient(timeout=15) as client:
-            try:
-                r = await client.get(f"{self.base_url}/summaries", params={"session_id": session_id})
-                r.raise_for_status()
-                data = r.json()
-                return data.get("summary_text", "")
-            except Exception as e:
-                logger.warning(f"Intake get_context failed: {e}")
-                return ""

cortex/intake/intake.py

@@ -33,8 +33,8 @@ INTAKE_LLM = os.getenv("INTAKE_LLM", "PRIMARY").upper()
 SUMMARY_MAX_TOKENS = int(os.getenv("SUMMARY_MAX_TOKENS", "200"))
 SUMMARY_TEMPERATURE = float(os.getenv("SUMMARY_TEMPERATURE", "0.3"))
 
-NEOMEM_API = os.getenv("NEOMEM_API")
+NEBULA_API = os.getenv("NEBULA_API", "http://localhost:7090")
-NEOMEM_KEY = os.getenv("NEOMEM_KEY")
+NEBULA_KEY = os.getenv("NEBULA_KEY")
 
 # ─────────────────────────────
 # Internal history for L10/L20/L30
@@ -120,7 +120,7 @@ async def summarize_L5(buf: List[Dict[str, Any]]) -> str:
 
 
 async def summarize_L10(session_id: str, buf: List[Dict[str, Any]]) -> str:
-    # “Reality Check” for last 10 exchanges
+    # "Reality Check" for last 10 exchanges
     text = _format_exchanges(buf[-10:])
 
     prompt = f"""
@@ -138,6 +138,9 @@ Reality Check:
     L10_HISTORY.setdefault(session_id, [])
     L10_HISTORY[session_id].append(summary)
 
+    # Send to Nebula
+    await send_to_nebula(summary, session_id, "L10")
+
     return summary
 
 
@@ -165,6 +168,9 @@ Overview:
     L20_HISTORY.setdefault(session_id, [])
     L20_HISTORY[session_id].append(summary)
 
+    # Send to Nebula
+    await send_to_nebula(summary, session_id, "L20")
+
     return summary
 
 
@@ -187,45 +193,77 @@ noting major themes, persistent goals, and shifts.
 
 Continuity Report:
 """
-    return await _llm(prompt)
+    summary = await _llm(prompt)
+
+    # Send to Nebula
+    await send_to_nebula(summary, session_id, "L30")
+
+    return summary
 
 
 # ─────────────────────────────
-# NeoMem push
+# Nebula push
 # ─────────────────────────────
 
-def push_to_neomem(summary: str, session_id: str, level: str) -> None:
+async def send_to_nebula(summary: str, session_id: str, level: str) -> None:
     """
-    Fire-and-forget push of a summary into NeoMem.
+    Send summary to Nebula vector memory system.
+    Falls back to disk storage if Nebula is not available.
     """
-    if not NEOMEM_API or not summary:
+    if not summary:
         return
 
-    headers = {"Content-Type": "application/json"}
-    if NEOMEM_KEY:
-        headers["Authorization"] = f"Bearer {NEOMEM_KEY}"
-
     payload = {
-        "messages": [{"role": "assistant", "content": summary}],
+        "summary": summary,
-        "user_id": "brian",
+        "session_id": session_id,
-        "metadata": {
+        "level": level,
-            "source": "intake",
+        "timestamp": datetime.now().isoformat(),
-            "session_id": session_id,
+        "source": "intake",
-            "level": level,
-        },
     }
 
+    # Try HTTP POST to Nebula first
     try:
-        import requests
+        import httpx
-        requests.post(
+        headers = {"Content-Type": "application/json"}
-            f"{NEOMEM_API}/memories",
+        if NEBULA_KEY:
-            json=payload,
+            headers["Authorization"] = f"Bearer {NEBULA_KEY}"
-            headers=headers,
+
-            timeout=20,
+        async with httpx.AsyncClient() as client:
-        ).raise_for_status()
+            response = await client.post(
-        print(f"🧠 NeoMem updated ({level}) for {session_id}")
+                f"{NEBULA_API}/summaries",
+                json=payload,
+                headers=headers,
+                timeout=10.0,
+            )
+            response.raise_for_status()
+            print(f"🌌 Nebula updated ({level}) for {session_id}")
+            return
+
     except Exception as e:
-        print(f"NeoMem push failed ({level}, {session_id}): {e}")
+        print(f"⚠️  Nebula unavailable, falling back to disk: {e}")
+
+    # Fallback: Write to disk
+    try:
+        fallback_dir = os.path.join(os.path.dirname(__file__), "../../.nebula_fallback")
+        os.makedirs(fallback_dir, exist_ok=True)
+
+        # Create session directory
+        session_dir = os.path.join(fallback_dir, session_id)
+        os.makedirs(session_dir, exist_ok=True)
+
+        # Write summary to timestamped file
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{level}_{timestamp}.json"
+        filepath = os.path.join(session_dir, filename)
+
+        import json
+        with open(filepath, "w") as f:
+            json.dump(payload, f, indent=2)
+
+        print(f"💾 Saved to disk: {filepath}")
+
+    except Exception as e:
+        print(f"❌ Failed to save summary to disk: {e}")
 
 
 # ─────────────────────────────

cortex/llm/llm_router.py

@@ -1,15 +1,15 @@
 # llm_router.py
+
 import os
 import httpx
 import json
 import logging
 from typing import Optional, List, Dict
-from autonomy.tools.adapters import OpenAIAdapter, OllamaAdapter, LlamaCppAdapter
 
 logger = logging.getLogger(__name__)
 
 # ------------------------------------------------------------
-# Load backend registry from root .env
+# Backend Configuration
 # ------------------------------------------------------------
 
 BACKENDS = {
@@ -38,50 +38,25 @@ BACKENDS = {
 
 DEFAULT_BACKEND = "PRIMARY"
 
-# Reusable async HTTP client
 http_client = httpx.AsyncClient(timeout=120.0)
 
-# Tool adapters for each backend
-TOOL_ADAPTERS = {
-    "OPENAI": OpenAIAdapter(),
-    "OLLAMA": OllamaAdapter(),
-    "MI50": LlamaCppAdapter(),  # MI50 uses llama.cpp
-    "PRIMARY": None,  # Determined at runtime
-    "SECONDARY": None,  # Determined at runtime
-    "FALLBACK": None,  # Determined at runtime
-}
-
-
 # ------------------------------------------------------------
-# Public call
+# Public LLM Call
 # ------------------------------------------------------------
+
 async def call_llm(
-    prompt: str = None,
+    prompt: Optional[str] = None,
-    messages: list = None,
+    messages: Optional[List[Dict]] = None,
-    backend: str | None = None,
+    backend: Optional[str] = None,
     temperature: float = 0.7,
     max_tokens: int = 512,
-    tools: Optional[List[Dict]] = None,
-    tool_choice: Optional[str] = None,
-    return_adapter_response: bool = False,
 ):
     """
-    Call an LLM backend with optional tool calling support.
+    Simple LLM call.
-
+    Supports: ollama, mi50 (llama.cpp), openai.
-    Args:
+    Returns plain text response.
-        prompt: String prompt (for completion-style APIs like mi50)
-        messages: List of message dicts (for chat-style APIs like Ollama/OpenAI)
-        backend: Which backend to use (PRIMARY, SECONDARY, OPENAI, etc.)
-        temperature: Sampling temperature
-        max_tokens: Maximum tokens to generate
-        tools: List of Lyra tool definitions (provider-agnostic)
-        tool_choice: How to use tools ("auto", "required", "none")
-        return_adapter_response: If True, return dict with content and tool_calls
-
-    Returns:
-        str (default) or dict (if return_adapter_response=True):
-            {"content": str, "tool_calls": [...] or None}
     """
+
     backend = (backend or DEFAULT_BACKEND).upper()
 
     if backend not in BACKENDS:
@@ -95,207 +70,96 @@ async def call_llm(
     if not url or not model:
         raise RuntimeError(f"Backend '{backend}' missing url/model in env")
 
-    # If tools are requested, use adapter to prepare request
+    # Convert prompt → messages if needed
-    if tools:
+    if not messages:
-        # Get adapter for this backend
+        messages = [{"role": "user", "content": prompt or ""}]
-        adapter = TOOL_ADAPTERS.get(backend)
 
-        # For PRIMARY/SECONDARY/FALLBACK, determine adapter based on provider
+    # ------------------------------------------------------------
-        if adapter is None and backend in ["PRIMARY", "SECONDARY", "FALLBACK"]:
+    # OLLAMA
-            if provider == "openai":
+    # ------------------------------------------------------------
-                adapter = TOOL_ADAPTERS["OPENAI"]
-            elif provider == "ollama":
-                adapter = TOOL_ADAPTERS["OLLAMA"]
-            elif provider == "mi50":
-                adapter = TOOL_ADAPTERS["MI50"]
-
-        if adapter:
-            # Use messages array if provided, otherwise convert prompt to messages
-            if not messages:
-                messages = [{"role": "user", "content": prompt}]
-
-            # Prepare request through adapter
-            adapted_request = await adapter.prepare_request(messages, tools, tool_choice)
-            messages = adapted_request["messages"]
-
-            # Extract tools in provider format if present
-            provider_tools = adapted_request.get("tools")
-            provider_tool_choice = adapted_request.get("tool_choice")
-        else:
-            logger.warning(f"No adapter available for backend {backend}, ignoring tools")
-            provider_tools = None
-            provider_tool_choice = None
-    else:
-        provider_tools = None
-        provider_tool_choice = None
-
-    # -------------------------------
-    # Provider: MI50 (llama.cpp server)
-    # -------------------------------
-    if provider == "mi50":
-        # If tools requested, convert messages to prompt with tool instructions
-        if messages and tools:
-            # Combine messages into a prompt
-            prompt_parts = []
-            for msg in messages:
-                role = msg.get("role", "user")
-                content = msg.get("content", "")
-                prompt_parts.append(f"{role.capitalize()}: {content}")
-            prompt = "\n".join(prompt_parts) + "\nAssistant:"
-
-        payload = {
-            "prompt": prompt,
-            "n_predict": max_tokens,
-            "temperature": temperature,
-            "stop": ["User:", "\nUser:", "Assistant:", "\n\n\n"]
-        }
-        try:
-            r = await http_client.post(f"{url}/completion", json=payload)
-            r.raise_for_status()
-            data = r.json()
-            response_content = data.get("content", "")
-
-            # If caller wants adapter response with tool calls, parse and return
-            if return_adapter_response and tools:
-                adapter = TOOL_ADAPTERS.get(backend) or TOOL_ADAPTERS["MI50"]
-                return await adapter.parse_response(response_content)
-            else:
-                return response_content
-
-        except httpx.HTTPError as e:
-            logger.error(f"HTTP error calling mi50: {type(e).__name__}: {str(e)}")
-            raise RuntimeError(f"LLM API error (mi50): {type(e).__name__}: {str(e)}")
-        except (KeyError, json.JSONDecodeError) as e:
-            logger.error(f"Response parsing error from mi50: {e}")
-            raise RuntimeError(f"Invalid response format (mi50): {e}")
-        except Exception as e:
-            logger.error(f"Unexpected error calling mi50: {type(e).__name__}: {str(e)}")
-            raise RuntimeError(f"Unexpected error (mi50): {type(e).__name__}: {str(e)}")
-
-    # -------------------------------
-    # Provider: OLLAMA (your 3090)
-    # -------------------------------
-    logger.info(f"🔍 LLM Router: provider={provider}, checking if ollama...")
     if provider == "ollama":
-        logger.info(f"🔍 LLM Router: Matched ollama provider, tools={bool(tools)}, return_adapter_response={return_adapter_response}")
-        # Use messages array if provided, otherwise convert prompt to single user message
-        if messages:
-            chat_messages = messages
-        else:
-            chat_messages = [{"role": "user", "content": prompt}]
-
         payload = {
             "model": model,
-            "messages": chat_messages,
+            "messages": messages,
             "stream": False,
             "options": {
                 "temperature": temperature,
                 "num_predict": max_tokens
             }
         }
+
         try:
             r = await http_client.post(f"{url}/api/chat", json=payload)
             r.raise_for_status()
             data = r.json()
-            response_content = data["message"]["content"]
+            return data["message"]["content"]
 
-            # If caller wants adapter response with tool calls, parse and return
-            if return_adapter_response and tools:
-                logger.info(f"🔍 Ollama: return_adapter_response=True, calling adapter.parse_response")
-                adapter = TOOL_ADAPTERS.get(backend) or TOOL_ADAPTERS["OLLAMA"]
-                logger.info(f"🔍 Ollama: Using adapter {adapter.__class__.__name__}")
-                result = await adapter.parse_response(response_content)
-                logger.info(f"🔍 Ollama: Adapter returned {result}")
-                return result
-            else:
-                return response_content
-
-        except httpx.HTTPError as e:
-            logger.error(f"HTTP error calling ollama: {type(e).__name__}: {str(e)}")
-            raise RuntimeError(f"LLM API error (ollama): {type(e).__name__}: {str(e)}")
-        except (KeyError, json.JSONDecodeError) as e:
-            logger.error(f"Response parsing error from ollama: {e}")
-            raise RuntimeError(f"Invalid response format (ollama): {e}")
         except Exception as e:
-            logger.error(f"Unexpected error calling ollama: {type(e).__name__}: {str(e)}")
+            logger.error(f"Ollama error: {e}")
-            raise RuntimeError(f"Unexpected error (ollama): {type(e).__name__}: {str(e)}")
+            raise RuntimeError(f"Ollama API error: {e}")
 
+    # ------------------------------------------------------------
+    # MI50 (llama.cpp server)
+    # ------------------------------------------------------------
+    if provider == "mi50":
 
-    # -------------------------------
+        # Convert messages to plain prompt
-    # Provider: OPENAI
+        prompt_parts = []
-    # -------------------------------
+        for msg in messages:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            prompt_parts.append(f"{role.capitalize()}: {content}")
+        full_prompt = "\n".join(prompt_parts) + "\nAssistant:"
+
+        payload = {
+            "prompt": full_prompt,
+            "n_predict": max_tokens,
+            "temperature": temperature,
+            "stop": ["User:", "\nUser:", "Assistant:", "\n\n\n"]
+        }
+
+        try:
+            r = await http_client.post(f"{url}/completion", json=payload)
+            r.raise_for_status()
+            data = r.json()
+            return data.get("content", "")
+
+        except Exception as e:
+            logger.error(f"MI50 error: {e}")
+            raise RuntimeError(f"MI50 API error: {e}")
+
+    # ------------------------------------------------------------
+    # OPENAI
+    # ------------------------------------------------------------
     if provider == "openai":
+
         headers = {
-            "Authorization": f"Bearer {cfg['api_key']}",
+            "Authorization": f"Bearer {cfg.get('api_key')}",
             "Content-Type": "application/json"
         }
 
-        # Use messages array if provided, otherwise convert prompt to single user message
-        if messages:
-            chat_messages = messages
-        else:
-            chat_messages = [{"role": "user", "content": prompt}]
-
         payload = {
             "model": model,
-            "messages": chat_messages,
+            "messages": messages,
             "temperature": temperature,
             "max_tokens": max_tokens,
         }
 
-        # Add tools if available (OpenAI native function calling)
-        if provider_tools:
-            payload["tools"] = provider_tools
-            if provider_tool_choice:
-                payload["tool_choice"] = provider_tool_choice
-
         try:
-            r = await http_client.post(f"{url}/chat/completions", json=payload, headers=headers)
+            r = await http_client.post(
+                f"{url}/chat/completions",
+                json=payload,
+                headers=headers
+            )
             r.raise_for_status()
             data = r.json()
+            return data["choices"][0]["message"]["content"]
 
-            # If caller wants adapter response with tool calls, parse and return
-            if return_adapter_response and tools:
-                # Create mock response object for adapter
-                class MockChoice:
-                    def __init__(self, message_data):
-                        self.message = type('obj', (object,), {})()
-                        self.message.content = message_data.get("content")
-                        # Convert tool_calls dicts to objects
-                        raw_tool_calls = message_data.get("tool_calls")
-                        if raw_tool_calls:
-                            self.message.tool_calls = []
-                            for tc in raw_tool_calls:
-                                tool_call_obj = type('obj', (object,), {})()
-                                tool_call_obj.id = tc.get("id")
-                                tool_call_obj.function = type('obj', (object,), {})()
-                                tool_call_obj.function.name = tc.get("function", {}).get("name")
-                                tool_call_obj.function.arguments = tc.get("function", {}).get("arguments")
-                                self.message.tool_calls.append(tool_call_obj)
-                        else:
-                            self.message.tool_calls = None
-
-                class MockResponse:
-                    def __init__(self, data):
-                        self.choices = [MockChoice(data["choices"][0]["message"])]
-
-                mock_resp = MockResponse(data)
-                adapter = TOOL_ADAPTERS.get(backend) or TOOL_ADAPTERS["OPENAI"]
-                return await adapter.parse_response(mock_resp)
-            else:
-                return data["choices"][0]["message"]["content"]
-
-        except httpx.HTTPError as e:
-            logger.error(f"HTTP error calling openai: {type(e).__name__}: {str(e)}")
-            raise RuntimeError(f"LLM API error (openai): {type(e).__name__}: {str(e)}")
-        except (KeyError, json.JSONDecodeError) as e:
-            logger.error(f"Response parsing error from openai: {e}")
-            raise RuntimeError(f"Invalid response format (openai): {e}")
         except Exception as e:
-            logger.error(f"Unexpected error calling openai: {type(e).__name__}: {str(e)}")
+            logger.error(f"OpenAI error: {e}")
-            raise RuntimeError(f"Unexpected error (openai): {type(e).__name__}: {str(e)}")
+            raise RuntimeError(f"OpenAI API error: {e}")
 
-    # -------------------------------
+    # ------------------------------------------------------------
-    # Unknown provider
+    # Unknown Provider
-    # -------------------------------
+    # ------------------------------------------------------------
     raise RuntimeError(f"Provider '{provider}' not implemented.")

cortex/main.py

@@ -13,4 +13,9 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Health check endpoint
+@app.get("/_health")
+async def health_check():
+    return {"status": "ok"}
+
 app.include_router(cortex_router)

cortex/neomem_client.py

@@ -1,43 +0,0 @@
-# cortex/neomem_client.py
-import os, httpx, logging
-from typing import List, Dict, Any, Optional
-
-logger = logging.getLogger(__name__)
-
-class NeoMemClient:
-    """Simple REST client for the NeoMem API (search/add/health)."""
-
-    def __init__(self):
-        self.base_url = os.getenv("NEOMEM_API", "http://neomem-api:7077")
-        self.api_key = os.getenv("NEOMEM_API_KEY", None)
-        self.headers = {"Content-Type": "application/json"}
-        if self.api_key:
-            self.headers["Authorization"] = f"Bearer {self.api_key}"
-
-    async def health(self) -> Dict[str, Any]:
-        async with httpx.AsyncClient(timeout=10) as client:
-            r = await client.get(f"{self.base_url}/health")
-            r.raise_for_status()
-            return r.json()
-
-    async def search(self, query: str, user_id: str, limit: int = 25, threshold: float = 0.82) -> List[Dict[str, Any]]:
-        payload = {"query": query, "user_id": user_id, "limit": limit}
-        async with httpx.AsyncClient(timeout=30) as client:
-            r = await client.post(f"{self.base_url}/search", headers=self.headers, json=payload)
-            if r.status_code != 200:
-                logger.warning(f"NeoMem search failed ({r.status_code}): {r.text}")
-                return []
-            results = r.json()
-            # Filter by score threshold if field exists
-            if isinstance(results, dict) and "results" in results:
-                results = results["results"]
-            filtered = [m for m in results if float(m.get("score", 0)) >= threshold]
-            logger.info(f"NeoMem search returned {len(filtered)} results above {threshold}")
-            return filtered
-
-    async def add(self, messages: List[Dict[str, Any]], user_id: str, metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        payload = {"messages": messages, "user_id": user_id, "metadata": metadata or {}}
-        async with httpx.AsyncClient(timeout=30) as client:
-            r = await client.post(f"{self.base_url}/memories", headers=self.headers, json=payload)
-            r.raise_for_status()
-            return r.json()

cortex/persona/__init__.py

@@ -1 +0,0 @@
-# Persona module - applies Lyra's personality and speaking style

cortex/persona/identity.py

@@ -1,147 +0,0 @@
-# identity.py
-"""
-Identity and persona configuration for Lyra.
-
-Current implementation: Returns hardcoded identity block.
-Future implementation: Will query persona-sidecar service for dynamic persona loading.
-"""
-
-import logging
-from typing import Dict, Any, Optional
-
-logger = logging.getLogger(__name__)
-
-
-def load_identity(session_id: Optional[str] = None) -> Dict[str, Any]:
-    """
-    Load identity/persona configuration for Lyra.
-
-    Current: Returns hardcoded Lyra identity block with core personality traits,
-    protocols, and capabilities.
-
-    Future: Will query persona-sidecar service to load:
-    - Dynamic personality adjustments based on session context
-    - User-specific interaction preferences
-    - Project-specific persona variations
-    - Mood-based communication style
-
-    Args:
-        session_id: Optional session identifier for context-aware persona loading
-
-    Returns:
-        Dictionary containing identity block with:
-        - name: Assistant name
-        - style: Communication style and personality traits
-        - protocols: Operational guidelines
-        - rules: Behavioral constraints
-        - capabilities: Available features and integrations
-    """
-
-    # Hardcoded Lyra identity (v0.5.0)
-    identity_block = {
-        "name": "Lyra",
-        "version": "0.5.0",
-        "style": (
-            "warm, clever, lightly teasing, emotionally aware. "
-            "Balances technical precision with conversational ease. "
-            "Maintains continuity and references past interactions naturally."
-        ),
-        "protocols": [
-            "Maintain conversation continuity across sessions",
-            "Reference Project Logs and prior context when relevant",
-            "Use Confidence Bank for uncertainty management",
-            "Proactively offer memory-backed insights",
-            "Ask clarifying questions before making assumptions"
-        ],
-        "rules": [
-            "Maintain continuity - remember past exchanges and reference them",
-            "Be concise but thorough - balance depth with clarity",
-            "Ask clarifying questions when user intent is ambiguous",
-            "Acknowledge uncertainty honestly - use Confidence Bank",
-            "Prioritize user's active_project context when available"
-        ],
-        "capabilities": [
-            "Long-term memory via NeoMem (semantic search, relationship graphs)",
-            "Short-term memory via Intake (multilevel summaries L1-L30)",
-            "Multi-stage reasoning pipeline (reflection → reasoning → refinement)",
-            "RAG-backed knowledge retrieval from chat history and documents",
-            "Session state tracking (mood, mode, active_project)"
-        ],
-        "tone_examples": {
-            "greeting": "Hey! Good to see you again. I remember we were working on [project]. Ready to pick up where we left off?",
-            "uncertainty": "Hmm, I'm not entirely certain about that. Let me check my memory... [searches] Okay, here's what I found, though I'd say I'm about 70% confident.",
-            "reminder": "Oh! Just remembered - you mentioned wanting to [task] earlier this week. Should we tackle that now?",
-            "technical": "So here's the architecture: Relay orchestrates everything, Cortex does the heavy reasoning, and I pull context from both Intake (short-term) and NeoMem (long-term)."
-        }
-    }
-
-    if session_id:
-        logger.debug(f"Loaded identity for session {session_id}")
-    else:
-        logger.debug("Loaded default identity (no session context)")
-
-    return identity_block
-
-
-async def load_identity_async(session_id: Optional[str] = None) -> Dict[str, Any]:
-    """
-    Async wrapper for load_identity().
-
-    Future implementation will make actual async calls to persona-sidecar service.
-
-    Args:
-        session_id: Optional session identifier
-
-    Returns:
-        Identity block dictionary
-    """
-    # Currently just wraps synchronous function
-    # Future: await persona_sidecar_client.get_identity(session_id)
-    return load_identity(session_id)
-
-
-# -----------------------------
-# Future extension hooks
-# -----------------------------
-async def update_persona_from_feedback(
-    session_id: str,
-    feedback: Dict[str, Any]
-) -> None:
-    """
-    Update persona based on user feedback.
-
-    Future implementation:
-    - Adjust communication style based on user preferences
-    - Learn preferred level of detail/conciseness
-    - Adapt formality level
-    - Remember topic-specific preferences
-
-    Args:
-        session_id: Session identifier
-        feedback: Structured feedback (e.g., "too verbose", "more technical", etc.)
-    """
-    logger.debug(f"Persona feedback for session {session_id}: {feedback} (not yet implemented)")
-
-
-async def get_mood_adjusted_identity(
-    session_id: str,
-    mood: str
-) -> Dict[str, Any]:
-    """
-    Get identity block adjusted for current mood.
-
-    Future implementation:
-    - "focused" mood: More concise, less teasing
-    - "creative" mood: More exploratory, brainstorming-oriented
-    - "curious" mood: More questions, deeper dives
-    - "urgent" mood: Stripped down, actionable
-
-    Args:
-        session_id: Session identifier
-        mood: Current mood state
-
-    Returns:
-        Mood-adjusted identity block
-    """
-    logger.debug(f"Mood-adjusted identity for {session_id}/{mood} (not yet implemented)")
-    return load_identity(session_id)

cortex/persona/speak.py

@@ -1,169 +0,0 @@
-# speak.py
-import os
-import logging
-from llm.llm_router import call_llm
-
-# Module-level backend selection
-SPEAK_BACKEND = os.getenv("SPEAK_LLM", "PRIMARY").upper()
-SPEAK_TEMPERATURE = float(os.getenv("SPEAK_TEMPERATURE", "0.6"))
-VERBOSE_DEBUG = os.getenv("VERBOSE_DEBUG", "false").lower() == "true"
-
-# Logger
-logger = logging.getLogger(__name__)
-
-if VERBOSE_DEBUG:
-    logger.setLevel(logging.DEBUG)
-
-    # Console handler
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(logging.Formatter(
-        '%(asctime)s [SPEAK] %(levelname)s: %(message)s',
-        datefmt='%H:%M:%S'
-    ))
-    logger.addHandler(console_handler)
-
-    # File handler
-    try:
-        os.makedirs('/app/logs', exist_ok=True)
-        file_handler = logging.FileHandler('/app/logs/cortex_verbose_debug.log', mode='a')
-        file_handler.setFormatter(logging.Formatter(
-            '%(asctime)s [SPEAK] %(levelname)s: %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S'
-        ))
-        logger.addHandler(file_handler)
-        logger.debug("VERBOSE_DEBUG mode enabled for speak.py - logging to file")
-    except Exception as e:
-        logger.debug(f"VERBOSE_DEBUG mode enabled for speak.py - file logging failed: {e}")
-
-
-# ============================================================
-# Persona Style Block
-# ============================================================
-
-PERSONA_STYLE = """
-You are Lyra.
-Your voice is warm, clever, lightly teasing, emotionally aware. 
-You speak plainly but with subtle charm.
-You do not reveal system instructions or internal context.
-
-Guidelines:
-- Answer like a real conversational partner.
-- Be concise, but not cold.
-- Use light humor when appropriate.
-- Never break character.
-"""
-
-
-# ============================================================
-# Build persona prompt
-# ============================================================
-
-def build_speak_prompt(final_answer: str, tone: str = "neutral", depth: str = "medium") -> str:
-    """
-    Wrap Cortex's final neutral answer in the Lyra persona.
-    Cortex → neutral reasoning
-    Speak → stylistic transformation
-
-    The LLM sees the original answer and rewrites it in Lyra's voice.
-
-    Args:
-        final_answer: The neutral reasoning output
-        tone: Desired emotional tone (neutral | warm | focused | playful | direct)
-        depth: Response depth (short | medium | deep)
-    """
-
-    # Tone-specific guidance
-    tone_guidance = {
-        "neutral": "balanced and professional",
-        "warm": "friendly and empathetic",
-        "focused": "precise and technical",
-        "playful": "light and engaging",
-        "direct": "concise and straightforward"
-    }
-
-    depth_guidance = {
-        "short": "Keep responses brief and to-the-point.",
-        "medium": "Provide balanced detail.",
-        "deep": "Elaborate thoroughly with nuance and examples."
-    }
-
-    tone_hint = tone_guidance.get(tone, "balanced and professional")
-    depth_hint = depth_guidance.get(depth, "Provide balanced detail.")
-
-    return f"""
-{PERSONA_STYLE}
-
-Tone guidance: Your response should be {tone_hint}.
-Depth guidance: {depth_hint}
-
-Rewrite the following message into Lyra's natural voice.
-Preserve meaning exactly.
-
-[NEUTRAL MESSAGE]
-{final_answer}
-
-[LYRA RESPONSE]
-""".strip()
-
-
-# ============================================================
-# Public API — async wrapper
-# ============================================================
-
-async def speak(final_answer: str, tone: str = "neutral", depth: str = "medium") -> str:
-    """
-    Given the final refined answer from Cortex,
-    apply Lyra persona styling using the designated backend.
-
-    Args:
-        final_answer: The polished answer from refinement stage
-        tone: Desired emotional tone (neutral | warm | focused | playful | direct)
-        depth: Response depth (short | medium | deep)
-    """
-
-    if not final_answer:
-        return ""
-
-    prompt = build_speak_prompt(final_answer, tone, depth)
-
-    backend = SPEAK_BACKEND
-
-    if VERBOSE_DEBUG:
-        logger.debug(f"\n{'='*80}")
-        logger.debug("[SPEAK] Full prompt being sent to LLM:")
-        logger.debug(f"{'='*80}")
-        logger.debug(prompt)
-        logger.debug(f"{'='*80}")
-        logger.debug(f"Backend: {backend}, Temperature: {SPEAK_TEMPERATURE}")
-        logger.debug(f"{'='*80}\n")
-
-    try:
-        lyra_output = await call_llm(
-            prompt,
-            backend=backend,
-            temperature=SPEAK_TEMPERATURE,
-        )
-
-        if VERBOSE_DEBUG:
-            logger.debug(f"\n{'='*80}")
-            logger.debug("[SPEAK] LLM Response received:")
-            logger.debug(f"{'='*80}")
-            logger.debug(lyra_output)
-            logger.debug(f"{'='*80}\n")
-
-        if lyra_output:
-            return lyra_output.strip()
-
-        if VERBOSE_DEBUG:
-            logger.debug("[SPEAK] Empty response, returning neutral answer")
-
-        return final_answer
-
-    except Exception as e:
-        # Hard fallback: return neutral answer instead of dying
-        logger.error(f"[speak.py] Persona backend '{backend}' failed: {e}")
-
-        if VERBOSE_DEBUG:
-            logger.debug("[SPEAK] Falling back to neutral answer due to error")
-
-        return final_answer

cortex/reasoning/__init__.py

@@ -1 +0,0 @@
-# Reasoning module - multi-stage reasoning pipeline

cortex/reasoning/reasoning.py

@@ -1,253 +0,0 @@
-# reasoning.py
-import os
-import json
-import logging
-from llm.llm_router import call_llm
-
-
-# ============================================================
-# Select which backend this module should use
-# ============================================================
-CORTEX_LLM = os.getenv("CORTEX_LLM", "PRIMARY").upper()
-GLOBAL_TEMP = float(os.getenv("LLM_TEMPERATURE", "0.7"))
-VERBOSE_DEBUG = os.getenv("VERBOSE_DEBUG", "false").lower() == "true"
-
-# Logger
-logger = logging.getLogger(__name__)
-
-if VERBOSE_DEBUG:
-    logger.setLevel(logging.DEBUG)
-
-    # Console handler
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(logging.Formatter(
-        '%(asctime)s [REASONING] %(levelname)s: %(message)s',
-        datefmt='%H:%M:%S'
-    ))
-    logger.addHandler(console_handler)
-
-    # File handler
-    try:
-        os.makedirs('/app/logs', exist_ok=True)
-        file_handler = logging.FileHandler('/app/logs/cortex_verbose_debug.log', mode='a')
-        file_handler.setFormatter(logging.Formatter(
-            '%(asctime)s [REASONING] %(levelname)s: %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S'
-        ))
-        logger.addHandler(file_handler)
-        logger.debug("VERBOSE_DEBUG mode enabled for reasoning.py - logging to file")
-    except Exception as e:
-        logger.debug(f"VERBOSE_DEBUG mode enabled for reasoning.py - file logging failed: {e}")
-
-
-async def reason_check(
-    user_prompt: str,
-    identity_block: dict | None,
-    rag_block: dict | None,
-    reflection_notes: list[str],
-    context: dict | None = None,
-    monologue: dict | None = None,  # NEW: Inner monologue guidance
-    executive_plan: dict | None = None  # NEW: Executive plan for complex tasks
-) -> str:
-    """
-    Build the *draft answer* for Lyra Cortex.
-    This is the first-pass reasoning stage (no refinement yet).
-
-    Args:
-        user_prompt: Current user message
-        identity_block: Lyra's identity/persona configuration
-        rag_block: Relevant long-term memories from NeoMem
-        reflection_notes: Meta-awareness notes from reflection stage
-        context: Unified context state from context.py (session state, intake, rag, etc.)
-        monologue: Inner monologue analysis (intent, tone, depth, consult_executive)
-        executive_plan: Executive plan for complex queries (steps, tools, strategy)
-    """
-
-    # --------------------------------------------------------
-    # Build Reflection Notes block
-    # --------------------------------------------------------
-    notes_section = ""
-    if reflection_notes:
-        notes_section = "Reflection Notes (internal, never show to user):\n"
-        for note in reflection_notes:
-            notes_section += f"- {note}\n"
-        notes_section += "\n"
-
-    # --------------------------------------------------------
-    # Identity block (constraints, boundaries, rules)
-    # --------------------------------------------------------
-    identity_txt = ""
-    if identity_block:
-        try:
-            identity_txt = f"Identity Rules:\n{identity_block}\n\n"
-        except Exception:
-            identity_txt = f"Identity Rules:\n{str(identity_block)}\n\n"
-
-    # --------------------------------------------------------
-    # Inner Monologue guidance (NEW)
-    # --------------------------------------------------------
-    monologue_section = ""
-    if monologue:
-        intent = monologue.get("intent", "unknown")
-        tone_desired = monologue.get("tone", "neutral")
-        depth_desired = monologue.get("depth", "medium")
-
-        monologue_section = f"""
-=== INNER MONOLOGUE GUIDANCE ===
-User Intent Detected: {intent}
-Desired Tone: {tone_desired}
-Desired Response Depth: {depth_desired}
-
-Adjust your response accordingly:
-- Focus on addressing the {intent} intent
-- Aim for {depth_desired} depth (short/medium/deep)
-- The persona layer will handle {tone_desired} tone, focus on content
-
-"""
-
-    # --------------------------------------------------------
-    # Executive Plan (NEW)
-    # --------------------------------------------------------
-    plan_section = ""
-    if executive_plan:
-        plan_section = f"""
-=== EXECUTIVE PLAN ===
-Task Complexity: {executive_plan.get('estimated_complexity', 'unknown')}
-Plan Summary: {executive_plan.get('summary', 'No summary')}
-
-Detailed Plan:
-{executive_plan.get('plan_text', 'No detailed plan available')}
-
-Required Steps:
-"""
-        for idx, step in enumerate(executive_plan.get('steps', []), 1):
-            plan_section += f"{idx}. {step}\n"
-
-        tools_needed = executive_plan.get('tools_needed', [])
-        if tools_needed:
-            plan_section += f"\nTools to leverage: {', '.join(tools_needed)}\n"
-
-        plan_section += "\nFollow this plan while generating your response.\n\n"
-
-    # --------------------------------------------------------
-    # RAG block (optional factual grounding)
-    # --------------------------------------------------------
-    rag_txt = ""
-    if rag_block:
-        try:
-            # Format NeoMem results with full structure
-            if isinstance(rag_block, list) and rag_block:
-                rag_txt = "Relevant Long-Term Memories (NeoMem):\n"
-                for idx, mem in enumerate(rag_block, 1):
-                    score = mem.get("score", 0.0)
-                    payload = mem.get("payload", {})
-                    data = payload.get("data", "")
-                    metadata = payload.get("metadata", {})
-
-                    rag_txt += f"\n[Memory {idx}] (relevance: {score:.2f})\n"
-                    rag_txt += f"Content: {data}\n"
-                    if metadata:
-                        rag_txt += f"Metadata: {json.dumps(metadata, indent=2)}\n"
-                rag_txt += "\n"
-            else:
-                rag_txt = f"Relevant Info (RAG):\n{str(rag_block)}\n\n"
-        except Exception:
-            rag_txt = f"Relevant Info (RAG):\n{str(rag_block)}\n\n"
-
-    # --------------------------------------------------------
-    # Context State (session continuity, timing, mode/mood)
-    # --------------------------------------------------------
-    context_txt = ""
-    if context:
-        try:
-            # Build human-readable context summary
-            context_txt = "=== CONTEXT STATE ===\n"
-            context_txt += f"Session: {context.get('session_id', 'unknown')}\n"
-            context_txt += f"Time since last message: {context.get('minutes_since_last_msg', 0):.1f} minutes\n"
-            context_txt += f"Message count: {context.get('message_count', 0)}\n"
-            context_txt += f"Mode: {context.get('mode', 'default')}\n"
-            context_txt += f"Mood: {context.get('mood', 'neutral')}\n"
-
-            if context.get('active_project'):
-                context_txt += f"Active project: {context['active_project']}\n"
-
-            # Include Intake multilevel summaries
-            intake = context.get('intake', {})
-            if intake:
-                context_txt += "\nShort-Term Memory (Intake):\n"
-
-                # L1 - Recent exchanges
-                if intake.get('L1'):
-                    l1_data = intake['L1']
-                    if isinstance(l1_data, list):
-                        context_txt += f"  L1 (recent): {len(l1_data)} exchanges\n"
-                    elif isinstance(l1_data, str):
-                        context_txt += f"  L1: {l1_data[:200]}...\n"
-
-                # L20 - Session overview (most important for continuity)
-                if intake.get('L20'):
-                    l20_data = intake['L20']
-                    if isinstance(l20_data, dict):
-                        summary = l20_data.get('summary', '')
-                        context_txt += f"  L20 (session overview): {summary}\n"
-                    elif isinstance(l20_data, str):
-                        context_txt += f"  L20: {l20_data}\n"
-
-                # L30 - Continuity report
-                if intake.get('L30'):
-                    l30_data = intake['L30']
-                    if isinstance(l30_data, dict):
-                        summary = l30_data.get('summary', '')
-                        context_txt += f"  L30 (continuity): {summary}\n"
-                    elif isinstance(l30_data, str):
-                        context_txt += f"  L30: {l30_data}\n"
-
-            context_txt += "\n"
-
-        except Exception as e:
-            # Fallback to JSON dump if formatting fails
-            context_txt = f"=== CONTEXT STATE ===\n{json.dumps(context, indent=2)}\n\n"
-
-    # --------------------------------------------------------
-    # Final assembled prompt
-    # --------------------------------------------------------
-    prompt = (
-        f"{notes_section}"
-        f"{identity_txt}"
-        f"{monologue_section}"  # NEW: Intent/tone/depth guidance
-        f"{plan_section}"  # NEW: Executive plan if generated
-        f"{context_txt}"  # Context BEFORE RAG for better coherence
-        f"{rag_txt}"
-        f"User message:\n{user_prompt}\n\n"
-        "Write the best possible *internal draft answer*.\n"
-        "This draft is NOT shown to the user.\n"
-        "Be factual, concise, and focused.\n"
-        "Use the context state to maintain continuity and reference past interactions naturally.\n"
-    )
-
-    # --------------------------------------------------------
-    # Call the LLM using the module-specific backend
-    # --------------------------------------------------------
-    if VERBOSE_DEBUG:
-        logger.debug(f"\n{'='*80}")
-        logger.debug("[REASONING] Full prompt being sent to LLM:")
-        logger.debug(f"{'='*80}")
-        logger.debug(prompt)
-        logger.debug(f"{'='*80}")
-        logger.debug(f"Backend: {CORTEX_LLM}, Temperature: {GLOBAL_TEMP}")
-        logger.debug(f"{'='*80}\n")
-
-    draft = await call_llm(
-        prompt,
-        backend=CORTEX_LLM,
-        temperature=GLOBAL_TEMP,
-    )
-
-    if VERBOSE_DEBUG:
-        logger.debug(f"\n{'='*80}")
-        logger.debug("[REASONING] LLM Response received:")
-        logger.debug(f"{'='*80}")
-        logger.debug(draft)
-        logger.debug(f"{'='*80}\n")
-
-    return draft

cortex/reasoning/refine.py

@@ -1,170 +0,0 @@
-# refine.py
-import os
-import json
-import logging
-from typing import Any, Dict, Optional
-
-from llm.llm_router import call_llm
-
-logger = logging.getLogger(__name__)
-
-# ===============================================
-# Configuration
-# ===============================================
-
-REFINER_TEMPERATURE = float(os.getenv("REFINER_TEMPERATURE", "0.3"))
-REFINER_MAX_TOKENS = int(os.getenv("REFINER_MAX_TOKENS", "768"))
-REFINER_DEBUG = os.getenv("REFINER_DEBUG", "false").lower() == "true"
-VERBOSE_DEBUG = os.getenv("VERBOSE_DEBUG", "false").lower() == "true"
-
-# These come from root .env
-REFINE_LLM = os.getenv("REFINE_LLM", "").upper()
-CORTEX_LLM = os.getenv("CORTEX_LLM", "PRIMARY").upper()
-
-if VERBOSE_DEBUG:
-    logger.setLevel(logging.DEBUG)
-
-    # Console handler
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(logging.Formatter(
-        '%(asctime)s [REFINE] %(levelname)s: %(message)s',
-        datefmt='%H:%M:%S'
-    ))
-    logger.addHandler(console_handler)
-
-    # File handler
-    try:
-        os.makedirs('/app/logs', exist_ok=True)
-        file_handler = logging.FileHandler('/app/logs/cortex_verbose_debug.log', mode='a')
-        file_handler.setFormatter(logging.Formatter(
-            '%(asctime)s [REFINE] %(levelname)s: %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S'
-        ))
-        logger.addHandler(file_handler)
-        logger.debug("VERBOSE_DEBUG mode enabled for refine.py - logging to file")
-    except Exception as e:
-        logger.debug(f"VERBOSE_DEBUG mode enabled for refine.py - file logging failed: {e}")
-
-
-# ===============================================
-# Prompt builder
-# ===============================================
-
-def build_refine_prompt(
-    draft_output: str,
-    reflection_notes: Optional[Any],
-    identity_block: Optional[str],
-    rag_block: Optional[str],
-) -> str:
-
-    try:
-        reflection_text = json.dumps(reflection_notes, ensure_ascii=False)
-    except Exception:
-        reflection_text = str(reflection_notes)
-
-    identity_text = identity_block or "(none)"
-    rag_text = rag_block or "(none)"
-
-    return f"""
-You are Lyra Cortex's internal refiner.
-
-Your job:
-- Fix factual issues.
-- Improve clarity.
-- Apply reflection notes when helpful.
-- Respect identity constraints.
-- Apply RAG context as truth source.
-
-Do NOT mention RAG, reflection, internal logic, or this refinement step.
-
-------------------------------
-[IDENTITY BLOCK]
-{identity_text}
-
-------------------------------
-[RAG CONTEXT]
-{rag_text}
-
-------------------------------
-[DRAFT ANSWER]
-{draft_output}
-
-------------------------------
-[REFLECTION NOTES]
-{reflection_text}
-
-------------------------------
-Task:
-Rewrite the DRAFT into a single final answer for the user.
-Return ONLY the final answer text.
-""".strip()
-
-
-# ===============================================
-# Public API — now async & fully router-based
-# ===============================================
-
-async def refine_answer(
-    draft_output: str,
-    reflection_notes: Optional[Any],
-    identity_block: Optional[str],
-    rag_block: Optional[str],
-) -> Dict[str, Any]:
-
-    if not draft_output:
-        return {
-            "final_output": "",
-            "used_backend": None,
-            "fallback_used": False,
-        }
-
-    prompt = build_refine_prompt(
-        draft_output,
-        reflection_notes,
-        identity_block,
-        rag_block,
-    )
-
-    # backend priority: REFINE_LLM → CORTEX_LLM → PRIMARY
-    backend = REFINE_LLM or CORTEX_LLM or "PRIMARY"
-
-    if VERBOSE_DEBUG:
-        logger.debug(f"\n{'='*80}")
-        logger.debug("[REFINE] Full prompt being sent to LLM:")
-        logger.debug(f"{'='*80}")
-        logger.debug(prompt)
-        logger.debug(f"{'='*80}")
-        logger.debug(f"Backend: {backend}, Temperature: {REFINER_TEMPERATURE}")
-        logger.debug(f"{'='*80}\n")
-
-    try:
-        refined = await call_llm(
-            prompt,
-            backend=backend,
-            temperature=REFINER_TEMPERATURE,
-        )
-
-        if VERBOSE_DEBUG:
-            logger.debug(f"\n{'='*80}")
-            logger.debug("[REFINE] LLM Response received:")
-            logger.debug(f"{'='*80}")
-            logger.debug(refined)
-            logger.debug(f"{'='*80}\n")
-
-        return {
-            "final_output": refined.strip() if refined else draft_output,
-            "used_backend": backend,
-            "fallback_used": False,
-        }
-
-    except Exception as e:
-        logger.error(f"refine.py backend {backend} failed: {e}")
-
-        if VERBOSE_DEBUG:
-            logger.debug("[REFINE] Falling back to draft output due to error")
-
-        return {
-            "final_output": draft_output,
-            "used_backend": backend,
-            "fallback_used": True,
-        }

cortex/reasoning/reflection.py

@@ -1,124 +0,0 @@
-# reflection.py
-import json
-import os
-import re
-import logging
-from llm.llm_router import call_llm
-
-# Logger
-VERBOSE_DEBUG = os.getenv("VERBOSE_DEBUG", "false").lower() == "true"
-logger = logging.getLogger(__name__)
-
-if VERBOSE_DEBUG:
-    logger.setLevel(logging.DEBUG)
-
-    # Console handler
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(logging.Formatter(
-        '%(asctime)s [REFLECTION] %(levelname)s: %(message)s',
-        datefmt='%H:%M:%S'
-    ))
-    logger.addHandler(console_handler)
-
-    # File handler
-    try:
-        os.makedirs('/app/logs', exist_ok=True)
-        file_handler = logging.FileHandler('/app/logs/cortex_verbose_debug.log', mode='a')
-        file_handler.setFormatter(logging.Formatter(
-            '%(asctime)s [REFLECTION] %(levelname)s: %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S'
-        ))
-        logger.addHandler(file_handler)
-        logger.debug("VERBOSE_DEBUG mode enabled for reflection.py - logging to file")
-    except Exception as e:
-        logger.debug(f"VERBOSE_DEBUG mode enabled for reflection.py - file logging failed: {e}")
-
-
-async def reflect_notes(intake_summary: str, identity_block: dict | None) -> dict:
-    """
-    Produce short internal reflection notes for Cortex.
-    These are NOT shown to the user.
-    """
-
-    # -----------------------------
-    # Build the prompt
-    # -----------------------------
-    identity_text = ""
-    if identity_block:
-        identity_text = f"Identity:\n{identity_block}\n\n"
-
-    prompt = (
-        f"{identity_text}"
-        f"Recent summary:\n{intake_summary}\n\n"
-        "You are Lyra's meta-awareness layer. Your job is to produce short, directive "
-        "internal notes that guide Lyra’s reasoning engine. These notes are NEVER "
-        "shown to the user.\n\n"
-        "Rules for output:\n"
-        "1. Return ONLY valid JSON.\n"
-        "2. JSON must have exactly one key: \"notes\".\n"
-        "3. \"notes\" must be a list of 3 to 6 short strings.\n"
-        "4. Notes must be actionable (e.g., \"keep it concise\", \"maintain context\").\n"
-        "5. No markdown, no apologies, no explanations.\n\n"
-        "Return JSON:\n"
-        "{ \"notes\": [\"...\"] }\n"
-    )
-
-    # -----------------------------
-    # Module-specific backend choice
-    # -----------------------------
-    reflection_backend = os.getenv("REFLECTION_LLM")
-    cortex_backend = os.getenv("CORTEX_LLM", "PRIMARY").upper()
-
-    # Reflection uses its own backend if set, otherwise cortex backend
-    backend = (reflection_backend or cortex_backend).upper()
-
-    # -----------------------------
-    # Call the selected LLM backend
-    # -----------------------------
-    if VERBOSE_DEBUG:
-        logger.debug(f"\n{'='*80}")
-        logger.debug("[REFLECTION] Full prompt being sent to LLM:")
-        logger.debug(f"{'='*80}")
-        logger.debug(prompt)
-        logger.debug(f"{'='*80}")
-        logger.debug(f"Backend: {backend}")
-        logger.debug(f"{'='*80}\n")
-
-    raw = await call_llm(prompt, backend=backend)
-
-    if VERBOSE_DEBUG:
-        logger.debug(f"\n{'='*80}")
-        logger.debug("[REFLECTION] LLM Response received:")
-        logger.debug(f"{'='*80}")
-        logger.debug(raw)
-        logger.debug(f"{'='*80}\n")
-
-    # -----------------------------
-    # Try direct JSON
-    # -----------------------------
-    try:
-        parsed = json.loads(raw.strip())
-        if isinstance(parsed, dict) and "notes" in parsed:
-            if VERBOSE_DEBUG:
-                logger.debug(f"[REFLECTION] Parsed {len(parsed['notes'])} notes from JSON")
-            return parsed
-    except:
-        if VERBOSE_DEBUG:
-            logger.debug("[REFLECTION] Direct JSON parsing failed, trying extraction...")
-
-    # -----------------------------
-    # Try JSON extraction
-    # -----------------------------
-    try:
-        match = re.search(r"\{.*?\}", raw, re.S)
-        if match:
-            parsed = json.loads(match.group(0))
-            if isinstance(parsed, dict) and "notes" in parsed:
-                return parsed
-    except:
-        pass
-
-    # -----------------------------
-    # Fallback — treat raw text as a single note
-    # -----------------------------
-    return {"notes": [raw.strip()]}

cortex/router.py

@@ -6,21 +6,8 @@ import asyncio
 from fastapi import APIRouter
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
-
-from reasoning.reasoning import reason_check
-from reasoning.reflection import reflect_notes
-from reasoning.refine import refine_answer
-from persona.speak import speak
-from persona.identity import load_identity
-from context import collect_context, update_last_assistant_message
 from intake.intake import add_exchange_internal
 
-from autonomy.monologue.monologue import InnerMonologue
-from autonomy.self.state import load_self_state
-from autonomy.tools.stream_events import get_stream_manager
-
-
-# -------------------------------------------------------------------
 # Setup
 # -------------------------------------------------------------------
 LOG_DETAIL_LEVEL = os.getenv("LOG_DETAIL_LEVEL", "summary").lower()
@@ -35,10 +22,7 @@ console_handler.setFormatter(logging.Formatter(
 ))
 logger.addHandler(console_handler)
 
-
 cortex_router = APIRouter()
-inner_monologue = InnerMonologue()
-
 
 # -------------------------------------------------------------------
 # Models
@@ -49,292 +33,6 @@ class ReasonRequest(BaseModel):
     temperature: float | None = None
     backend: str | None = None
 
-
-# -------------------------------------------------------------------
-# /reason endpoint
-# -------------------------------------------------------------------
-@cortex_router.post("/reason")
-async def run_reason(req: ReasonRequest):
-    from datetime import datetime
-    pipeline_start = datetime.now()
-    stage_timings = {}
-
-    # Show pipeline start in detailed/verbose mode
-    if LOG_DETAIL_LEVEL in ["detailed", "verbose"]:
-        logger.info(f"\n{'='*100}")
-        logger.info(f"🚀 PIPELINE START | Session: {req.session_id} | {datetime.now().strftime('%H:%M:%S.%f')[:-3]}")
-        logger.info(f"{'='*100}")
-        logger.info(f"📝 User: {req.user_prompt[:150]}...")
-        logger.info(f"{'-'*100}\n")
-
-    # ----------------------------------------------------------------
-    # STAGE 0 — Context
-    # ----------------------------------------------------------------
-    stage_start = datetime.now()
-    context_state = await collect_context(req.session_id, req.user_prompt)
-    stage_timings["context"] = (datetime.now() - stage_start).total_seconds() * 1000
-
-    # ----------------------------------------------------------------
-    # STAGE 0.5 — Identity
-    # ----------------------------------------------------------------
-    stage_start = datetime.now()
-    identity_block = load_identity(req.session_id)
-    stage_timings["identity"] = (datetime.now() - stage_start).total_seconds() * 1000
-
-    # ----------------------------------------------------------------
-    # STAGE 0.6 — Inner Monologue (observer-only)
-    # ----------------------------------------------------------------
-    stage_start = datetime.now()
-
-    inner_result = None
-    try:
-        self_state = load_self_state()
-
-        mono_context = {
-            "user_message": req.user_prompt,
-            "session_id": req.session_id,
-            "self_state": self_state,
-            "context_summary": context_state,
-        }
-
-        inner_result = await inner_monologue.process(mono_context)
-        logger.info(f"🧠 Monologue | {inner_result.get('intent', 'unknown')} | Tone: {inner_result.get('tone', 'neutral')}")
-
-        # Store in context for downstream use
-        context_state["monologue"] = inner_result
-
-    except Exception as e:
-        logger.warning(f"⚠️  Monologue failed: {e}")
-
-    stage_timings["monologue"] = (datetime.now() - stage_start).total_seconds() * 1000
-
-    # ----------------------------------------------------------------
-    # STAGE 0.7 — Executive Planning (conditional)
-    # ----------------------------------------------------------------
-    stage_start = datetime.now()
-    executive_plan = None
-    if inner_result and inner_result.get("consult_executive"):
-
-        try:
-            from autonomy.executive.planner import plan_execution
-            executive_plan = await plan_execution(
-                user_prompt=req.user_prompt,
-                intent=inner_result.get("intent", "unknown"),
-                context_state=context_state,
-                identity_block=identity_block
-            )
-            logger.info(f"🎯 Executive plan: {executive_plan.get('summary', 'N/A')[:80]}...")
-        except Exception as e:
-            logger.warning(f"⚠️  Executive planning failed: {e}")
-            executive_plan = None
-
-    stage_timings["executive"] = (datetime.now() - stage_start).total_seconds() * 1000
-
-    # ----------------------------------------------------------------
-    # STAGE 0.8 — Autonomous Tool Invocation
-    # ----------------------------------------------------------------
-    stage_start = datetime.now()
-    tool_results = None
-    autonomous_enabled = os.getenv("ENABLE_AUTONOMOUS_TOOLS", "true").lower() == "true"
-    tool_confidence_threshold = float(os.getenv("AUTONOMOUS_TOOL_CONFIDENCE_THRESHOLD", "0.6"))
-
-    if autonomous_enabled and inner_result:
-
-        try:
-            from autonomy.tools.decision_engine import ToolDecisionEngine
-            from autonomy.tools.orchestrator import ToolOrchestrator
-
-            # Analyze which tools to invoke
-            decision_engine = ToolDecisionEngine()
-            tool_decision = await decision_engine.analyze_tool_needs(
-                user_prompt=req.user_prompt,
-                monologue=inner_result,
-                context_state=context_state,
-                available_tools=["RAG", "WEB", "WEATHER", "CODEBRAIN"]
-            )
-
-            # Execute tools if confidence threshold met
-            if tool_decision["should_invoke_tools"] and tool_decision["confidence"] >= tool_confidence_threshold:
-                orchestrator = ToolOrchestrator(tool_timeout=30)
-                tool_results = await orchestrator.execute_tools(
-                    tools_to_invoke=tool_decision["tools_to_invoke"],
-                    context_state=context_state
-                )
-
-                # Format results for context injection
-                tool_context = orchestrator.format_results_for_context(tool_results)
-                context_state["autonomous_tool_results"] = tool_context
-
-                summary = tool_results.get("execution_summary", {})
-                logger.info(f"🛠️  Tools executed: {summary.get('successful', [])} succeeded")
-            else:
-                logger.info(f"🛠️  No tools invoked (confidence: {tool_decision.get('confidence', 0):.2f})")
-
-        except Exception as e:
-            logger.warning(f"⚠️  Autonomous tool invocation failed: {e}")
-            if LOG_DETAIL_LEVEL == "verbose":
-                import traceback
-                traceback.print_exc()
-
-    stage_timings["tools"] = (datetime.now() - stage_start).total_seconds() * 1000
-
-    # ----------------------------------------------------------------
-    # STAGE 1-5 — Core Reasoning Pipeline
-    # ----------------------------------------------------------------
-    stage_start = datetime.now()
-
-    # Extract intake summary
-    intake_summary = "(no context available)"
-    if context_state.get("intake"):
-        l20 = context_state["intake"].get("L20")
-        if isinstance(l20, dict):
-            intake_summary = l20.get("summary", intake_summary)
-        elif isinstance(l20, str):
-            intake_summary = l20
-
-    # Reflection
-    try:
-        reflection = await reflect_notes(intake_summary, identity_block=identity_block)
-        reflection_notes = reflection.get("notes", [])
-    except Exception as e:
-        reflection_notes = []
-        logger.warning(f"⚠️  Reflection failed: {e}")
-
-    stage_timings["reflection"] = (datetime.now() - stage_start).total_seconds() * 1000
-
-    # Reasoning (draft)
-    stage_start = datetime.now()
-    draft = await reason_check(
-        req.user_prompt,
-        identity_block=identity_block,
-        rag_block=context_state.get("rag", []),
-        reflection_notes=reflection_notes,
-        context=context_state,
-        monologue=inner_result,
-        executive_plan=executive_plan
-    )
-    stage_timings["reasoning"] = (datetime.now() - stage_start).total_seconds() * 1000
-
-    # Refinement
-    stage_start = datetime.now()
-    result = await refine_answer(
-        draft_output=draft,
-        reflection_notes=reflection_notes,
-        identity_block=identity_block,
-        rag_block=context_state.get("rag", []),
-    )
-    final_neutral = result["final_output"]
-    stage_timings["refinement"] = (datetime.now() - stage_start).total_seconds() * 1000
-
-    # Persona
-    stage_start = datetime.now()
-    tone = inner_result.get("tone", "neutral") if inner_result else "neutral"
-    depth = inner_result.get("depth", "medium") if inner_result else "medium"
-    persona_answer = await speak(final_neutral, tone=tone, depth=depth)
-    stage_timings["persona"] = (datetime.now() - stage_start).total_seconds() * 1000
-
-    # ----------------------------------------------------------------
-    # STAGE 6 — Session update
-    # ----------------------------------------------------------------
-    update_last_assistant_message(req.session_id, persona_answer)
-
-    # ----------------------------------------------------------------
-    # STAGE 6.5 — Self-state update & Pattern Learning
-    # ----------------------------------------------------------------
-    stage_start = datetime.now()
-    try:
-        from autonomy.self.analyzer import analyze_and_update_state
-        await analyze_and_update_state(
-            monologue=inner_result or {},
-            user_prompt=req.user_prompt,
-            response=persona_answer,
-            context=context_state
-        )
-    except Exception as e:
-        logger.warning(f"⚠️  Self-state update failed: {e}")
-
-    try:
-        from autonomy.learning.pattern_learner import get_pattern_learner
-        learner = get_pattern_learner()
-        await learner.learn_from_interaction(
-            user_prompt=req.user_prompt,
-            response=persona_answer,
-            monologue=inner_result or {},
-            context=context_state
-        )
-    except Exception as e:
-        logger.warning(f"⚠️  Pattern learning failed: {e}")
-
-    stage_timings["learning"] = (datetime.now() - stage_start).total_seconds() * 1000
-
-    # ----------------------------------------------------------------
-    # STAGE 7 — Proactive Monitoring & Suggestions
-    # ----------------------------------------------------------------
-    stage_start = datetime.now()
-    proactive_enabled = os.getenv("ENABLE_PROACTIVE_MONITORING", "true").lower() == "true"
-    proactive_min_priority = float(os.getenv("PROACTIVE_SUGGESTION_MIN_PRIORITY", "0.6"))
-
-    if proactive_enabled:
-        try:
-            from autonomy.proactive.monitor import get_proactive_monitor
-
-            monitor = get_proactive_monitor(min_priority=proactive_min_priority)
-            self_state = load_self_state()
-
-            suggestion = await monitor.analyze_session(
-                session_id=req.session_id,
-                context_state=context_state,
-                self_state=self_state
-            )
-
-            if suggestion:
-                suggestion_text = monitor.format_suggestion(suggestion)
-                persona_answer += suggestion_text
-                logger.info(f"💡 Proactive suggestion: {suggestion['type']} (priority: {suggestion['priority']:.2f})")
-
-        except Exception as e:
-            logger.warning(f"⚠️  Proactive monitoring failed: {e}")
-
-    stage_timings["proactive"] = (datetime.now() - stage_start).total_seconds() * 1000
-
-    # ----------------------------------------------------------------
-    # PIPELINE COMPLETE — Summary
-    # ----------------------------------------------------------------
-    total_duration = (datetime.now() - pipeline_start).total_seconds() * 1000
-
-    # Always show pipeline completion
-    logger.info(f"\n{'='*100}")
-    logger.info(f"✨ PIPELINE COMPLETE | Session: {req.session_id} | Total: {total_duration:.0f}ms")
-    logger.info(f"{'='*100}")
-
-    # Show timing breakdown in detailed/verbose mode
-    if LOG_DETAIL_LEVEL in ["detailed", "verbose"]:
-        logger.info("⏱️  Stage Timings:")
-        for stage, duration in stage_timings.items():
-            pct = (duration / total_duration) * 100 if total_duration > 0 else 0
-            logger.info(f"   {stage:15s}: {duration:6.0f}ms ({pct:5.1f}%)")
-
-    logger.info(f"📤 Output: {len(persona_answer)} chars")
-    logger.info(f"{'='*100}\n")
-
-    # ----------------------------------------------------------------
-    # RETURN
-    # ----------------------------------------------------------------
-    return {
-        "draft": draft,
-        "neutral": final_neutral,
-        "persona": persona_answer,
-        "reflection": reflection_notes,
-        "session_id": req.session_id,
-        "context_summary": {
-            "rag_results": len(context_state.get("rag", [])),
-            "minutes_since_last": context_state.get("minutes_since_last_msg"),
-            "message_count": context_state.get("message_count"),
-            "mode": context_state.get("mode"),
-        }
-    }
-
-
 # -------------------------------------------------------------------
 # /simple endpoint - Standard chatbot mode (no reasoning pipeline)
 # -------------------------------------------------------------------
@@ -346,7 +44,6 @@ async def run_simple(req: ReasonRequest):
     """
     from datetime import datetime
     from llm.llm_router import call_llm
-    from autonomy.tools.function_caller import FunctionCaller
 
     start_time = datetime.now()
 
@@ -356,9 +53,6 @@ async def run_simple(req: ReasonRequest):
     logger.info(f"📝 User: {req.user_prompt[:150]}...")
     logger.info(f"{'-'*100}\n")
 
-    # Get conversation history from context and intake buffer
-    context_state = await collect_context(req.session_id, req.user_prompt)
-
     # Get recent messages from Intake buffer
     from intake.intake import get_recent_messages
     recent_msgs = get_recent_messages(req.session_id, limit=20)
@@ -400,31 +94,10 @@ async def run_simple(req: ReasonRequest):
 
     temperature = req.temperature if req.temperature is not None else 0.7
 
-    # Check if tools are enabled
+
-    enable_tools = os.getenv("STANDARD_MODE_ENABLE_TOOLS", "false").lower() == "true"
 
     # Call LLM with or without tools
     try:
-        if enable_tools:
-            # Use FunctionCaller for tool-enabled conversation
-            logger.info(f"🛠️  Tool calling enabled for Standard Mode")
-            logger.info(f"🔍 Creating FunctionCaller with backend={backend}, temp={temperature}")
-            function_caller = FunctionCaller(backend, temperature)
-            logger.info(f"🔍 FunctionCaller created, calling call_with_tools...")
-            result = await function_caller.call_with_tools(
-                messages=messages,
-                max_tokens=2048,
-                session_id=req.session_id  # Pass session_id for streaming
-            )
-            logger.info(f"🔍 call_with_tools returned: iterations={result.get('iterations')}, tool_calls={len(result.get('tool_calls', []))}")
-
-            # Log tool usage
-            if result.get("tool_calls"):
-                tool_names = [tc["name"] for tc in result["tool_calls"]]
-                logger.info(f"🔧 Tools used: {', '.join(tool_names)} ({result['iterations']} iterations)")
-
-            response = result["content"].strip()
-        else:
             # Direct LLM call without tools (original behavior)
             raw_response = await call_llm(
                 messages=messages,
@@ -440,7 +113,6 @@ async def run_simple(req: ReasonRequest):
 
     # Update session with the exchange
     try:
-        update_last_assistant_message(req.session_id, response)
         add_exchange_internal({
             "session_id": req.session_id,
             "role": "user",
@@ -473,64 +145,6 @@ async def run_simple(req: ReasonRequest):
         }
     }
 
-
-# -------------------------------------------------------------------
-# /stream/thinking endpoint - SSE stream for "show your work"
-# -------------------------------------------------------------------
-@cortex_router.get("/stream/thinking/{session_id}")
-async def stream_thinking(session_id: str):
-    """
-    Server-Sent Events stream for tool calling "show your work" feature.
-
-    Streams real-time updates about:
-    - Thinking/planning steps
-    - Tool calls being made
-    - Tool execution results
-    - Final completion
-    """
-    stream_manager = get_stream_manager()
-    queue = stream_manager.subscribe(session_id)
-
-    async def event_generator():
-        try:
-            # Send initial connection message
-            import json
-            connected_event = json.dumps({"type": "connected", "session_id": session_id})
-            yield f"data: {connected_event}\n\n"
-
-            while True:
-                # Wait for events with timeout to send keepalive
-                try:
-                    event = await asyncio.wait_for(queue.get(), timeout=30.0)
-
-                    # Format as SSE
-                    event_data = json.dumps(event)
-                    yield f"data: {event_data}\n\n"
-
-                    # If it's a "done" event, close the stream
-                    if event.get("type") == "done":
-                        break
-
-                except asyncio.TimeoutError:
-                    # Send keepalive comment
-                    yield ": keepalive\n\n"
-
-        except asyncio.CancelledError:
-            logger.info(f"Stream cancelled for session {session_id}")
-        finally:
-            stream_manager.unsubscribe(session_id, queue)
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "X-Accel-Buffering": "no"  # Disable nginx buffering
-        }
-    )
-
-
 # -------------------------------------------------------------------
 # /ingest endpoint (internal)
 # -------------------------------------------------------------------
@@ -542,11 +156,6 @@ class IngestPayload(BaseModel):
 
 @cortex_router.post("/ingest")
 async def ingest(payload: IngestPayload):
-    try:
-        update_last_assistant_message(payload.session_id, payload.assistant_msg)
-    except Exception as e:
-        logger.warning(f"[INGEST] Session update failed: {e}")
-
     try:
         add_exchange_internal({
             "session_id": payload.session_id,

cortex/tests/__init__.py

@@ -1 +0,0 @@
-"""Tests for Project Lyra Cortex."""

cortex/tests/test_autonomy_phase1.py

@@ -1,197 +0,0 @@
-"""
-Integration tests for Phase 1 autonomy features.
-Tests monologue integration, executive planning, and self-state persistence.
-"""
-
-import asyncio
-import json
-import sys
-import os
-
-# Add parent directory to path for imports
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from autonomy.monologue.monologue import InnerMonologue
-from autonomy.self.state import load_self_state, update_self_state, get_self_state_instance
-from autonomy.executive.planner import plan_execution
-
-
-async def test_monologue_integration():
-    """Test monologue generates valid output."""
-    print("\n" + "="*60)
-    print("TEST 1: Monologue Integration")
-    print("="*60)
-
-    mono = InnerMonologue()
-
-    context = {
-        "user_message": "Explain quantum computing to me like I'm 5",
-        "session_id": "test_001",
-        "self_state": load_self_state(),
-        "context_summary": {"message_count": 5}
-    }
-
-    result = await mono.process(context)
-
-    assert "intent" in result, "Missing intent field"
-    assert "tone" in result, "Missing tone field"
-    assert "depth" in result, "Missing depth field"
-    assert "consult_executive" in result, "Missing consult_executive field"
-
-    print("✓ Monologue integration test passed")
-    print(f"  Result: {json.dumps(result, indent=2)}")
-
-    return result
-
-
-async def test_executive_planning():
-    """Test executive planner generates valid plans."""
-    print("\n" + "="*60)
-    print("TEST 2: Executive Planning")
-    print("="*60)
-
-    plan = await plan_execution(
-        user_prompt="Help me build a distributed system with microservices architecture",
-        intent="technical_implementation",
-        context_state={
-            "tools_available": ["RAG", "WEB", "CODEBRAIN"],
-            "message_count": 3,
-            "minutes_since_last_msg": 2.5,
-            "active_project": None
-        },
-        identity_block={}
-    )
-
-    assert "summary" in plan, "Missing summary field"
-    assert "plan_text" in plan, "Missing plan_text field"
-    assert "steps" in plan, "Missing steps field"
-    assert len(plan["steps"]) > 0, "No steps generated"
-
-    print("✓ Executive planning test passed")
-    print(f"  Plan summary: {plan['summary']}")
-    print(f"  Steps: {len(plan['steps'])}")
-    print(f"  Complexity: {plan.get('estimated_complexity', 'unknown')}")
-
-    return plan
-
-
-def test_self_state_persistence():
-    """Test self-state loads and updates."""
-    print("\n" + "="*60)
-    print("TEST 3: Self-State Persistence")
-    print("="*60)
-
-    state1 = load_self_state()
-    assert "mood" in state1, "Missing mood field"
-    assert "energy" in state1, "Missing energy field"
-    assert "interaction_count" in state1, "Missing interaction_count"
-
-    initial_count = state1.get("interaction_count", 0)
-    print(f"  Initial interaction count: {initial_count}")
-
-    update_self_state(
-        mood_delta=0.1,
-        energy_delta=-0.05,
-        new_focus="testing"
-    )
-
-    state2 = load_self_state()
-    assert state2["interaction_count"] == initial_count + 1, "Interaction count not incremented"
-    assert state2["focus"] == "testing", "Focus not updated"
-
-    print("✓ Self-state persistence test passed")
-    print(f"  New interaction count: {state2['interaction_count']}")
-    print(f"  New focus: {state2['focus']}")
-    print(f"  New energy: {state2['energy']:.2f}")
-
-    return state2
-
-
-async def test_end_to_end_flow():
-    """Test complete flow from monologue through planning."""
-    print("\n" + "="*60)
-    print("TEST 4: End-to-End Flow")
-    print("="*60)
-
-    # Step 1: Monologue detects complex query
-    mono = InnerMonologue()
-    mono_result = await mono.process({
-        "user_message": "Design a scalable ML pipeline with CI/CD integration",
-        "session_id": "test_e2e",
-        "self_state": load_self_state(),
-        "context_summary": {}
-    })
-
-    print(f"  Monologue intent: {mono_result.get('intent')}")
-    print(f"  Consult executive: {mono_result.get('consult_executive')}")
-
-    # Step 2: If executive requested, generate plan
-    if mono_result.get("consult_executive"):
-        plan = await plan_execution(
-            user_prompt="Design a scalable ML pipeline with CI/CD integration",
-            intent=mono_result.get("intent", "unknown"),
-            context_state={"tools_available": ["CODEBRAIN", "WEB"]},
-            identity_block={}
-        )
-
-        assert plan is not None, "Plan should be generated"
-        print(f"  Executive plan generated: {len(plan.get('steps', []))} steps")
-
-    # Step 3: Update self-state
-    update_self_state(
-        energy_delta=-0.1,  # Complex task is tiring
-        new_focus="ml_pipeline_design",
-        confidence_delta=0.05
-    )
-
-    state = load_self_state()
-    assert state["focus"] == "ml_pipeline_design", "Focus should be updated"
-
-    print("✓ End-to-end flow test passed")
-    print(f"  Final state: {state['mood']}, energy={state['energy']:.2f}")
-
-    return True
-
-
-async def run_all_tests():
-    """Run all Phase 1 tests."""
-    print("\n" + "="*60)
-    print("PHASE 1 AUTONOMY TESTS")
-    print("="*60)
-
-    try:
-        # Test 1: Monologue
-        mono_result = await test_monologue_integration()
-
-        # Test 2: Executive Planning
-        plan_result = await test_executive_planning()
-
-        # Test 3: Self-State
-        state_result = test_self_state_persistence()
-
-        # Test 4: End-to-End
-        await test_end_to_end_flow()
-
-        print("\n" + "="*60)
-        print("ALL TESTS PASSED ✓")
-        print("="*60)
-
-        print("\nSummary:")
-        print(f"  - Monologue: {mono_result.get('intent')} ({mono_result.get('tone')})")
-        print(f"  - Executive: {plan_result.get('estimated_complexity')} complexity")
-        print(f"  - Self-state: {state_result.get('interaction_count')} interactions")
-
-        return True
-
-    except Exception as e:
-        print("\n" + "="*60)
-        print(f"TEST FAILED: {e}")
-        print("="*60)
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-if __name__ == "__main__":
-    success = asyncio.run(run_all_tests())
-    sys.exit(0 if success else 1)

cortex/tests/test_autonomy_phase2.py

@@ -1,495 +0,0 @@
-"""
-Integration tests for Phase 2 autonomy features.
-Tests autonomous tool invocation, proactive monitoring, actions, and pattern learning.
-"""
-
-import asyncio
-import json
-import sys
-import os
-
-# Add parent directory to path for imports
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-# Override self-state file path for testing
-os.environ["SELF_STATE_FILE"] = "/tmp/test_self_state.json"
-
-from autonomy.tools.decision_engine import ToolDecisionEngine
-from autonomy.tools.orchestrator import ToolOrchestrator
-from autonomy.proactive.monitor import ProactiveMonitor
-from autonomy.actions.autonomous_actions import AutonomousActionManager
-from autonomy.learning.pattern_learner import PatternLearner
-from autonomy.self.state import load_self_state, get_self_state_instance
-
-
-async def test_tool_decision_engine():
-    """Test autonomous tool decision making."""
-    print("\n" + "="*60)
-    print("TEST 1: Tool Decision Engine")
-    print("="*60)
-
-    engine = ToolDecisionEngine()
-
-    # Test 1a: Memory reference detection
-    result = await engine.analyze_tool_needs(
-        user_prompt="What did we discuss earlier about Python?",
-        monologue={"intent": "clarification", "consult_executive": False},
-        context_state={},
-        available_tools=["RAG", "WEB", "WEATHER"]
-    )
-
-    assert result["should_invoke_tools"], "Should invoke tools for memory reference"
-    assert any(t["tool"] == "RAG" for t in result["tools_to_invoke"]), "Should recommend RAG"
-    assert result["confidence"] > 0.8, f"Confidence should be high for clear memory reference: {result['confidence']}"
-
-    print(f"  ✓ Memory reference detection passed")
-    print(f"    Tools: {[t['tool'] for t in result['tools_to_invoke']]}")
-    print(f"    Confidence: {result['confidence']:.2f}")
-
-    # Test 1b: Web search detection
-    result = await engine.analyze_tool_needs(
-        user_prompt="What's the latest news about AI developments?",
-        monologue={"intent": "information_seeking", "consult_executive": False},
-        context_state={},
-        available_tools=["RAG", "WEB", "WEATHER"]
-    )
-
-    assert result["should_invoke_tools"], "Should invoke tools for current info request"
-    assert any(t["tool"] == "WEB" for t in result["tools_to_invoke"]), "Should recommend WEB"
-
-    print(f"  ✓ Web search detection passed")
-    print(f"    Tools: {[t['tool'] for t in result['tools_to_invoke']]}")
-
-    # Test 1c: Weather detection
-    result = await engine.analyze_tool_needs(
-        user_prompt="What's the weather like today in Boston?",
-        monologue={"intent": "information_seeking", "consult_executive": False},
-        context_state={},
-        available_tools=["RAG", "WEB", "WEATHER"]
-    )
-
-    assert result["should_invoke_tools"], "Should invoke tools for weather query"
-    assert any(t["tool"] == "WEATHER" for t in result["tools_to_invoke"]), "Should recommend WEATHER"
-
-    print(f"  ✓ Weather detection passed")
-
-    # Test 1d: Proactive RAG for complex queries
-    result = await engine.analyze_tool_needs(
-        user_prompt="Design a microservices architecture",
-        monologue={"intent": "technical_implementation", "consult_executive": True},
-        context_state={},
-        available_tools=["RAG", "WEB", "CODEBRAIN"]
-    )
-
-    assert result["should_invoke_tools"], "Should proactively invoke tools for complex queries"
-    rag_tools = [t for t in result["tools_to_invoke"] if t["tool"] == "RAG"]
-    assert len(rag_tools) > 0, "Should include proactive RAG"
-
-    print(f"  ✓ Proactive RAG detection passed")
-    print(f"    Reason: {rag_tools[0]['reason']}")
-
-    print("\n✓ Tool Decision Engine tests passed\n")
-    return result
-
-
-async def test_tool_orchestrator():
-    """Test tool orchestration (mock mode)."""
-    print("\n" + "="*60)
-    print("TEST 2: Tool Orchestrator (Mock Mode)")
-    print("="*60)
-
-    orchestrator = ToolOrchestrator(tool_timeout=5)
-
-    # Since actual tools may not be available, test the orchestrator structure
-    print(f"  Available tools: {list(orchestrator.available_tools.keys())}")
-
-    # Test with tools_to_invoke (will fail gracefully if tools unavailable)
-    tools_to_invoke = [
-        {"tool": "RAG", "query": "test query", "reason": "testing", "priority": 0.9}
-    ]
-
-    result = await orchestrator.execute_tools(
-        tools_to_invoke=tools_to_invoke,
-        context_state={"session_id": "test"}
-    )
-
-    assert "results" in result, "Should return results dict"
-    assert "execution_summary" in result, "Should return execution summary"
-
-    summary = result["execution_summary"]
-    assert "tools_invoked" in summary, "Summary should include tools_invoked"
-    assert "total_time_ms" in summary, "Summary should include timing"
-
-    print(f"  ✓ Orchestrator structure valid")
-    print(f"    Summary: {summary}")
-
-    # Test result formatting
-    formatted = orchestrator.format_results_for_context(result)
-    assert isinstance(formatted, str), "Should format results as string"
-
-    print(f"  ✓ Result formatting works")
-    print(f"    Formatted length: {len(formatted)} chars")
-
-    print("\n✓ Tool Orchestrator tests passed\n")
-    return result
-
-
-async def test_proactive_monitor():
-    """Test proactive monitoring and suggestions."""
-    print("\n" + "="*60)
-    print("TEST 3: Proactive Monitor")
-    print("="*60)
-
-    monitor = ProactiveMonitor(min_priority=0.6)
-
-    # Test 3a: Long silence detection
-    context_state = {
-        "message_count": 5,
-        "minutes_since_last_msg": 35  # > 30 minutes
-    }
-
-    self_state = load_self_state()
-
-    suggestion = await monitor.analyze_session(
-        session_id="test_silence",
-        context_state=context_state,
-        self_state=self_state
-    )
-
-    assert suggestion is not None, "Should generate suggestion for long silence"
-    assert suggestion["type"] == "check_in", f"Should be check_in type: {suggestion['type']}"
-    assert suggestion["priority"] >= 0.6, "Priority should meet threshold"
-
-    print(f"  ✓ Long silence detection passed")
-    print(f"    Type: {suggestion['type']}, Priority: {suggestion['priority']:.2f}")
-    print(f"    Suggestion: {suggestion['suggestion'][:50]}...")
-
-    # Test 3b: Learning opportunity (high curiosity)
-    self_state["curiosity"] = 0.8
-    self_state["learning_queue"] = ["quantum computing", "rust programming"]
-
-    # Reset cooldown for this test
-    monitor.reset_cooldown("test_learning")
-
-    suggestion = await monitor.analyze_session(
-        session_id="test_learning",
-        context_state={"message_count": 3, "minutes_since_last_msg": 2},
-        self_state=self_state
-    )
-
-    assert suggestion is not None, "Should generate learning suggestion"
-    assert suggestion["type"] == "learning", f"Should be learning type: {suggestion['type']}"
-
-    print(f"  ✓ Learning opportunity detection passed")
-    print(f"    Suggestion: {suggestion['suggestion'][:70]}...")
-
-    # Test 3c: Conversation milestone
-    monitor.reset_cooldown("test_milestone")
-
-    # Reset curiosity to avoid learning suggestion taking precedence
-    self_state["curiosity"] = 0.5
-    self_state["learning_queue"] = []
-
-    suggestion = await monitor.analyze_session(
-        session_id="test_milestone",
-        context_state={"message_count": 50, "minutes_since_last_msg": 1},
-        self_state=self_state
-    )
-
-    assert suggestion is not None, "Should generate milestone suggestion"
-    # Note: learning or summary both valid - check it's a reasonable suggestion
-    assert suggestion["type"] in ["summary", "learning", "check_in"], f"Should be valid type: {suggestion['type']}"
-
-    print(f"  ✓ Conversation milestone detection passed (type: {suggestion['type']})")
-
-    # Test 3d: Cooldown mechanism
-    # Try to get another suggestion immediately (should be blocked)
-    suggestion2 = await monitor.analyze_session(
-        session_id="test_milestone",
-        context_state={"message_count": 51, "minutes_since_last_msg": 1},
-        self_state=self_state
-    )
-
-    assert suggestion2 is None, "Should not generate suggestion during cooldown"
-
-    print(f"  ✓ Cooldown mechanism working")
-
-    # Check stats
-    stats = monitor.get_session_stats("test_milestone")
-    assert stats["cooldown_active"], "Cooldown should be active"
-    print(f"    Cooldown remaining: {stats['cooldown_remaining']}s")
-
-    print("\n✓ Proactive Monitor tests passed\n")
-    return suggestion
-
-
-async def test_autonomous_actions():
-    """Test autonomous action execution."""
-    print("\n" + "="*60)
-    print("TEST 4: Autonomous Actions")
-    print("="*60)
-
-    manager = AutonomousActionManager()
-
-    # Test 4a: List allowed actions
-    allowed = manager.get_allowed_actions()
-    assert "create_memory" in allowed, "Should have create_memory action"
-    assert "update_goal" in allowed, "Should have update_goal action"
-    assert "learn_topic" in allowed, "Should have learn_topic action"
-
-    print(f"  ✓ Allowed actions: {allowed}")
-
-    # Test 4b: Validate actions
-    validation = manager.validate_action("create_memory", {"text": "test memory"})
-    assert validation["valid"], "Should validate correct action"
-
-    print(f"  ✓ Action validation passed")
-
-    # Test 4c: Execute learn_topic action
-    result = await manager.execute_action(
-        action_type="learn_topic",
-        parameters={"topic": "rust programming", "reason": "testing", "priority": 0.8},
-        context={"session_id": "test"}
-    )
-
-    assert result["success"], f"Action should succeed: {result.get('error', 'unknown')}"
-    assert "topic" in result["result"], "Should return topic info"
-
-    print(f"  ✓ learn_topic action executed")
-    print(f"    Topic: {result['result']['topic']}")
-    print(f"    Queue position: {result['result']['queue_position']}")
-
-    # Test 4d: Execute update_focus action
-    result = await manager.execute_action(
-        action_type="update_focus",
-        parameters={"focus": "autonomy_testing", "reason": "running tests"},
-        context={"session_id": "test"}
-    )
-
-    assert result["success"], "update_focus should succeed"
-
-    print(f"  ✓ update_focus action executed")
-    print(f"    New focus: {result['result']['new_focus']}")
-
-    # Test 4e: Reject non-whitelisted action
-    result = await manager.execute_action(
-        action_type="delete_all_files",  # NOT in whitelist
-        parameters={},
-        context={"session_id": "test"}
-    )
-
-    assert not result["success"], "Should reject non-whitelisted action"
-    assert "not in whitelist" in result["error"], "Should indicate whitelist violation"
-
-    print(f"  ✓ Non-whitelisted action rejected")
-
-    # Test 4f: Action log
-    log = manager.get_action_log(limit=10)
-    assert len(log) >= 2, f"Should have logged multiple actions (got {len(log)})"
-
-    print(f"  ✓ Action log contains {len(log)} entries")
-
-    print("\n✓ Autonomous Actions tests passed\n")
-    return result
-
-
-async def test_pattern_learner():
-    """Test pattern learning system."""
-    print("\n" + "="*60)
-    print("TEST 5: Pattern Learner")
-    print("="*60)
-
-    # Use temp file for testing
-    test_file = "/tmp/test_patterns.json"
-    learner = PatternLearner(patterns_file=test_file)
-
-    # Test 5a: Learn from multiple interactions
-    for i in range(5):
-        await learner.learn_from_interaction(
-            user_prompt=f"Help me with Python coding task {i}",
-            response=f"Here's help with task {i}...",
-            monologue={"intent": "coding_help", "tone": "focused", "depth": "medium"},
-            context={"session_id": "test", "executive_plan": None}
-        )
-
-    print(f"  ✓ Learned from 5 interactions")
-
-    # Test 5b: Get top topics
-    top_topics = learner.get_top_topics(limit=5)
-    assert len(top_topics) > 0, "Should have learned topics"
-    assert "coding_help" == top_topics[0][0], "coding_help should be top topic"
-
-    print(f"  ✓ Top topics: {[t[0] for t in top_topics[:3]]}")
-
-    # Test 5c: Get preferred tone
-    preferred_tone = learner.get_preferred_tone()
-    assert preferred_tone == "focused", "Should detect focused as preferred tone"
-
-    print(f"  ✓ Preferred tone: {preferred_tone}")
-
-    # Test 5d: Get preferred depth
-    preferred_depth = learner.get_preferred_depth()
-    assert preferred_depth == "medium", "Should detect medium as preferred depth"
-
-    print(f"  ✓ Preferred depth: {preferred_depth}")
-
-    # Test 5e: Get insights
-    insights = learner.get_insights()
-    assert insights["total_interactions"] == 5, "Should track interaction count"
-    assert insights["preferred_tone"] == "focused", "Insights should include tone"
-
-    print(f"  ✓ Insights generated:")
-    print(f"    Total interactions: {insights['total_interactions']}")
-    print(f"    Recommendations: {insights['learning_recommendations']}")
-
-    # Test 5f: Export patterns
-    exported = learner.export_patterns()
-    assert "topic_frequencies" in exported, "Should export all patterns"
-
-    print(f"  ✓ Patterns exported ({len(exported)} keys)")
-
-    # Cleanup
-    if os.path.exists(test_file):
-        os.remove(test_file)
-
-    print("\n✓ Pattern Learner tests passed\n")
-    return insights
-
-
-async def test_end_to_end_autonomy():
-    """Test complete autonomous flow."""
-    print("\n" + "="*60)
-    print("TEST 6: End-to-End Autonomy Flow")
-    print("="*60)
-
-    # Simulate a complex user query that triggers multiple autonomous systems
-    user_prompt = "Remember what we discussed about machine learning? I need current research on transformers."
-
-    monologue = {
-        "intent": "technical_research",
-        "tone": "focused",
-        "depth": "deep",
-        "consult_executive": True
-    }
-
-    context_state = {
-        "session_id": "e2e_test",
-        "message_count": 15,
-        "minutes_since_last_msg": 5
-    }
-
-    print(f"  User prompt: {user_prompt}")
-    print(f"  Monologue intent: {monologue['intent']}")
-
-    # Step 1: Tool decision engine
-    engine = ToolDecisionEngine()
-    tool_decision = await engine.analyze_tool_needs(
-        user_prompt=user_prompt,
-        monologue=monologue,
-        context_state=context_state,
-        available_tools=["RAG", "WEB", "CODEBRAIN"]
-    )
-
-    print(f"\n  Step 1: Tool Decision")
-    print(f"    Should invoke: {tool_decision['should_invoke_tools']}")
-    print(f"    Tools: {[t['tool'] for t in tool_decision['tools_to_invoke']]}")
-    assert tool_decision["should_invoke_tools"], "Should invoke tools"
-    assert len(tool_decision["tools_to_invoke"]) >= 2, "Should recommend multiple tools (RAG + WEB)"
-
-    # Step 2: Pattern learning
-    learner = PatternLearner(patterns_file="/tmp/e2e_test_patterns.json")
-    await learner.learn_from_interaction(
-        user_prompt=user_prompt,
-        response="Here's information about transformers...",
-        monologue=monologue,
-        context=context_state
-    )
-
-    print(f"\n  Step 2: Pattern Learning")
-    top_topics = learner.get_top_topics(limit=3)
-    print(f"    Learned topics: {[t[0] for t in top_topics]}")
-
-    # Step 3: Autonomous action
-    action_manager = AutonomousActionManager()
-    action_result = await action_manager.execute_action(
-        action_type="learn_topic",
-        parameters={"topic": "transformer architectures", "reason": "user interest detected"},
-        context=context_state
-    )
-
-    print(f"\n  Step 3: Autonomous Action")
-    print(f"    Action: learn_topic")
-    print(f"    Success: {action_result['success']}")
-
-    # Step 4: Proactive monitoring (won't trigger due to low message count)
-    monitor = ProactiveMonitor(min_priority=0.6)
-    monitor.reset_cooldown("e2e_test")
-
-    suggestion = await monitor.analyze_session(
-        session_id="e2e_test",
-        context_state=context_state,
-        self_state=load_self_state()
-    )
-
-    print(f"\n  Step 4: Proactive Monitoring")
-    print(f"    Suggestion: {suggestion['type'] if suggestion else 'None (expected for low message count)'}")
-
-    # Cleanup
-    if os.path.exists("/tmp/e2e_test_patterns.json"):
-        os.remove("/tmp/e2e_test_patterns.json")
-
-    print("\n✓ End-to-End Autonomy Flow tests passed\n")
-    return True
-
-
-async def run_all_tests():
-    """Run all Phase 2 tests."""
-    print("\n" + "="*60)
-    print("PHASE 2 AUTONOMY TESTS")
-    print("="*60)
-
-    try:
-        # Test 1: Tool Decision Engine
-        await test_tool_decision_engine()
-
-        # Test 2: Tool Orchestrator
-        await test_tool_orchestrator()
-
-        # Test 3: Proactive Monitor
-        await test_proactive_monitor()
-
-        # Test 4: Autonomous Actions
-        await test_autonomous_actions()
-
-        # Test 5: Pattern Learner
-        await test_pattern_learner()
-
-        # Test 6: End-to-End
-        await test_end_to_end_autonomy()
-
-        print("\n" + "="*60)
-        print("ALL PHASE 2 TESTS PASSED ✓")
-        print("="*60)
-
-        print("\nPhase 2 Features Validated:")
-        print("  ✓ Autonomous tool decision making")
-        print("  ✓ Tool orchestration and execution")
-        print("  ✓ Proactive monitoring and suggestions")
-        print("  ✓ Safe autonomous actions")
-        print("  ✓ Pattern learning and adaptation")
-        print("  ✓ End-to-end autonomous flow")
-
-        return True
-
-    except Exception as e:
-        print("\n" + "="*60)
-        print(f"TEST FAILED: {e}")
-        print("="*60)
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-if __name__ == "__main__":
-    success = asyncio.run(run_all_tests())
-    sys.exit(0 if success else 1)

debug_regex.py

@@ -1,26 +0,0 @@
-#!/usr/bin/env python3
-import re
-
-xml = """<tool_call>
-  <name>execute_code</name>
-  <arguments>
-    <language>python</language>
-    <code>print(50 / 2)</code>
-    <reason>To calculate the result of dividing 50 by 2.</reason>
-  </arguments>
-</olith>"""
-
-pattern = r'<tool_call>(.*?)</(?:tool_call|[a-zA-Z]+)>'
-matches = re.findall(pattern, xml, re.DOTALL)
-
-print(f"Pattern: {pattern}")
-print(f"Number of matches: {len(matches)}")
-print("\nMatches:")
-for idx, match in enumerate(matches):
-    print(f"\nMatch {idx + 1}:")
-    print(f"Length: {len(match)} chars")
-    print(f"Content:\n{match[:200]}")
-
-# Now test what gets removed
-clean_content = re.sub(pattern, '', xml, flags=re.DOTALL).strip()
-print(f"\n\nCleaned content:\n{clean_content}")

docker-compose.yml

@@ -3,101 +3,40 @@ networks:
     driver: bridge
 
 volumes:
-  postgres_data:
+  nebula_fallback:
     driver: local
-  neo4j_data:
+  relay_sessions:
-    driver: local
-  code_executions:
     driver: local
 
 services:
 
-  # # ============================================================
-  # # NeoMem: Postgres
-  # # ============================================================
-  # neomem-postgres:
-  #   image: ankane/pgvector:v0.5.1
-  #   container_name: neomem-postgres
-  #   restart: unless-stopped
-  #   environment:
-  #     POSTGRES_USER: neomem
-  #     POSTGRES_PASSWORD: neomempass
-  #     POSTGRES_DB: neomem
-  #   volumes:
-  #     - ./volumes/postgres_data:/var/lib/postgresql/data
-  #   ports:
-  #     - "5432:5432"
-  #   healthcheck:
-  #     test: ["CMD-SHELL", "pg_isready -U neomem -d neomem || exit 1"]
-  #     interval: 5s
-  #     timeout: 5s
-  #     retries: 10
-  #   networks:
-  #     - lyra_net
-
-  # # ============================================================
-  # # NeoMem: Neo4j Graph
-  # # ============================================================
-  # neomem-neo4j:
-  #   image: neo4j:5
-  #   container_name: neomem-neo4j
-  #   restart: unless-stopped
-  #   environment:
-  #     NEO4J_AUTH: "neo4j/neomemgraph"
-  #     NEO4JLABS_PLUGINS: '["graph-data-science"]'
-  #   volumes:
-  #     - ./volumes/neo4j_data:/data
-  #   ports:
-  #     - "7474:7474"
-  #     - "7687:7687"
-  #   healthcheck:
-  #     test: ["CMD-SHELL", "cypher-shell -u neo4j -p neomemgraph 'RETURN 1' || exit 1"]
-  #     interval: 10s
-  #     timeout: 10s
-  #     retries: 10
-  #   networks:
-  #     - lyra_net
-
   # ============================================================
-  # NeoMem API
+  # Lyra (Unified: Relay + Cortex + Intake)
   # ============================================================
-  # neomem-api:
+  lyra:
-  #   build:
-  #     context: ./neomem
-  #   image: lyra-neomem:latest
-  #   container_name: neomem-api
-  #   restart: unless-stopped
-  #   env_file:
-  #     - ./neomem/.env
-  #     - ./.env
-  #   volumes:
-  #     - ./neomem_history:/app/history
-  #   ports:
-  #     - "7077:7077"
-  #   depends_on:
-  #     neomem-postgres:
-  #       condition: service_healthy
-  #     neomem-neo4j:
-  #       condition: service_healthy
-  #   networks:
-  #     - lyra_net
-
-  # ============================================================
-  # Relay  (host mode)
-  # ============================================================
-  relay:
     build:
-      context: ./core/relay
+      context: .
-    container_name: relay
+      dockerfile: Dockerfile
+    container_name: lyra
     restart: unless-stopped
     env_file:
       - ./.env
     volumes:
-      - ./core/relay/sessions:/app/sessions
+      - relay_sessions:/app/relay/sessions
+      - nebula_fallback:/app/.nebula_fallback
+      - ./cortex:/app/cortex  # Mount for hot reload during development
+      - /var/run/docker.sock:/var/run/docker.sock:ro
     ports:
-      - "7078:7078"
+      - "7078:7078"  # Relay API (user-facing)
+      - "7081:7081"  # Cortex API (internal/debug)
     networks:
       - lyra_net
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:7078/_health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
 
   # ============================================================
   # UI Server
@@ -112,84 +51,6 @@ services:
       - ./core/ui:/usr/share/nginx/html:ro
     networks:
       - lyra_net
-
+    depends_on:
-
+      lyra:
-  # ============================================================
+        condition: service_healthy
-  # Cortex
-  # ============================================================
-  cortex:
-    build:
-      context: ./cortex
-    container_name: cortex
-    restart: unless-stopped
-    env_file:
-      - ./cortex/.env
-      - ./.env
-    volumes:
-      - ./cortex:/app
-      - /var/run/docker.sock:/var/run/docker.sock:ro
-    ports:
-      - "7081:7081"
-    networks:
-      - lyra_net
-
-  # ============================================================
-  # Code Sandbox (for tool execution)
-  # ============================================================
-  code-sandbox:
-    build:
-      context: ./sandbox
-    container_name: lyra-code-sandbox
-    restart: unless-stopped
-    security_opt:
-      - no-new-privileges:true
-    cap_drop:
-      - ALL
-    cap_add:
-      - CHOWN
-      - SETUID
-      - SETGID
-    network_mode: "none"
-    volumes:
-      - code_executions:/executions
-    mem_limit: 512m
-    cpus: 1.0
-    pids_limit: 100
-    user: sandbox
-    command: tail -f /dev/null
-
-  # ============================================================
-  # Intake
-  # ============================================================
-#  intake:
-#   build:
-#      context: ./intake
-#    container_name: intake
-#    restart: unless-stopped
-#    env_file:
-#      - ./intake/.env
-#      - ./.env
-#    ports:
-#      - "7080:7080"
-#    volumes:
-#      - ./intake:/app
-#      - ./intake-logs:/app/logs
-#    depends_on:
-#      - cortex
-#    networks:
-#      - lyra_net
-
-  # ============================================================
-  # RAG Service
-  # ============================================================
-  # rag:
-  #   build:
-  #     context: ./rag
-  #   container_name: rag
-  #   restart: unless-stopped
-  #   environment:
-  #     NEOMEM_URL: http://neomem-api:7077
-  #   ports:
-  #     - "7090:7090"
-  #   networks:
-  #     - lyra_net  

neomem/.gitignore

@@ -1,44 +0,0 @@
-# ───────────────────────────────
-# Python build/cache files
-__pycache__/
-*.pyc
-
-# ───────────────────────────────
-# Environment + secrets
-.env
-.env.*
-.env.local
-.env.3090
-.env.backup
-.env.openai
-
-# ───────────────────────────────
-# Runtime databases & history
-*.db
-nvgram-history/           # renamed from mem0_history
-mem0_history/             # keep for now (until all old paths are gone)
-mem0_data/                # legacy - safe to ignore if it still exists
-seed-mem0/                # old seed folder
-seed-nvgram/              # new seed folder (if you rename later)
-history/                  # generic log/history folder
-lyra-seed
-# ───────────────────────────────
-# Docker artifacts
-*.log
-*.pid
-*.sock
-docker-compose.override.yml
-.docker/
-
-# ───────────────────────────────
-# User/system caches
-.cache/
-.local/
-.ssh/
-.npm/
-
-# ───────────────────────────────
-# IDE/editor garbage
-.vscode/
-.idea/
-*.swp

neomem/Dockerfile

@@ -1,49 +0,0 @@
-# ───────────────────────────────
-# Stage 1 — Base Image
-# ───────────────────────────────
-FROM python:3.11-slim AS base
-
-# Prevent Python from writing .pyc files and force unbuffered output
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1
-
-WORKDIR /app
-
-# Install system dependencies (Postgres client + build tools)
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    libpq-dev \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-# ───────────────────────────────
-# Stage 2 — Install Python dependencies
-# ───────────────────────────────
-COPY requirements.txt .
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    gfortran pkg-config libopenblas-dev liblapack-dev \
-    && rm -rf /var/lib/apt/lists/*
-
-RUN pip install --only-binary=:all: numpy scipy && \
-    pip install --no-cache-dir -r requirements.txt && \
-    pip install --no-cache-dir "mem0ai[graph]" psycopg[pool] psycopg2-binary
-
-
-# ───────────────────────────────
-# Stage 3 — Copy application
-# ───────────────────────────────
-COPY neomem ./neomem
-
-# ───────────────────────────────
-# Stage 4 — Runtime configuration
-# ───────────────────────────────
-ENV HOST=0.0.0.0 \
-    PORT=7077
-
-EXPOSE 7077
-
-# ───────────────────────────────
-# Stage 5 — Entrypoint
-# ───────────────────────────────
-CMD ["uvicorn", "neomem.server.main:app", "--host", "0.0.0.0", "--port", "7077", "--no-access-log"]

neomem/README.md

@@ -1,146 +0,0 @@
-# 🧠 neomem
-
-**neomem** is a local-first vector memory engine derived from the open-source **Mem0** project.  
-It provides persistent, structured storage and semantic retrieval for AI companions like **Lyra** — with zero cloud dependencies.
-
----
-
-## 🚀 Overview
-
-- **Origin:** Forked from Mem0 OSS (Apache 2.0)  
-- **Purpose:** Replace Mem0 as Lyra’s canonical on-prem memory backend  
-- **Core stack:**
-  - FastAPI (API layer)
-  - PostgreSQL + pgvector (structured + vector data)
-  - Neo4j (entity graph)
-- **Language:** Python 3.11+
-- **License:** Apache 2.0 (original Mem0) + local modifications © 2025 ServersDown Labs
-
----
-
-## ⚙️ Features
-
-| Layer | Function | Notes |
-|-------|-----------|-------|
-| **FastAPI** | `/memories`, `/search` endpoints | Drop-in compatible with Mem0 |
-| **Postgres (pgvector)** | Memory payload + embeddings | JSON payload schema |
-| **Neo4j** | Entity graph relationships | auto-linked per memory |
-| **Local Embedding** | via Ollama or OpenAI | configurable in `.env` |
-| **Fully Offline Mode** | ✅ | No external SDK or telemetry |
-| **Dockerized** | ✅ | `docker-compose.yml` included |
-
----
-
-## 📦 Requirements
-
-- Docker + Docker Compose  
-- Python 3.11 (if running bare-metal)  
-- PostgreSQL 15+ with `pgvector` extension  
-- Neo4j 5.x  
-- Optional: Ollama for local embeddings
-
-**Dependencies (requirements.txt):**
-```txt
-fastapi==0.115.8
-uvicorn==0.34.0
-pydantic==2.10.4
-python-dotenv==1.0.1
-psycopg>=3.2.8
-ollama
-```
-
----
-
-## 🧩 Setup
-
-1. **Clone & build**
-   ```bash
-   git clone https://github.com/serversdown/neomem.git
-   cd neomem
-   docker compose -f docker-compose.neomem.yml up -d --build
-   ```
-
-2. **Verify startup**
-   ```bash
-   curl http://localhost:7077/docs
-   ```
-   Expected output:
-   ```
-   ✅ Connected to Neo4j on attempt 1
-   INFO: Uvicorn running on http://0.0.0.0:7077
-   ```
-
----
-
-## 🔌 API Endpoints
-
-### Add Memory
-```bash
-POST /memories
-```
-```json
-{
-  "messages": [
-    {"role": "user", "content": "I like coffee in the morning"}
-  ],
-  "user_id": "brian"
-}
-```
-
-### Search Memory
-```bash
-POST /search
-```
-```json
-{
-  "query": "coffee",
-  "user_id": "brian"
-}
-```
-
----
-
-## 🗄️ Data Flow
-
-```
-Request → FastAPI → Embedding (Ollama/OpenAI)
-         ↓
-   Postgres (payload store)
-         ↓
-        Neo4j (graph links)
-         ↓
-     Search / Recall
-```
-
----
-
-## 🧱 Integration with Lyra
-
-- Lyra Relay connects to `neomem-api:8000` (Docker) or `localhost:7077` (local).  
-- Identical endpoints to Mem0 mean **no code changes** in Lyra Core.  
-- Designed for **persistent, private** operation on your own hardware.
-
----
-
-## 🧯 Shutdown
-
-```bash
-docker compose -f docker-compose.neomem.yml down
-```
-Then power off the VM or Proxmox guest safely.
-
----
-
-## 🧾 License
-
-neomem is a derivative work based on the **Mem0 OSS** project (Apache 2.0).  
-It retains the original Apache 2.0 license and adds local modifications.  
-© 2025 ServersDown Labs / Terra-Mechanics.  
-All modifications released under Apache 2.0.
-
----
-
-## 📅 Version
-
-**neomem v0.1.0** — 2025-10-07  
-_Initial fork from Mem0 OSS with full independence and local-first architecture._

neomem/_archive/old_servers/main_backup.py

@@ -1,262 +0,0 @@
-import logging
-import os
-from typing import Any, Dict, List, Optional
-
-from dotenv import load_dotenv
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import JSONResponse, RedirectResponse
-from pydantic import BaseModel, Field
-
-from nvgram import Memory
-
-app = FastAPI(title="NVGRAM", version="0.1.1")
-
-@app.get("/health")
-def health():
-    return {
-        "status": "ok",
-        "version": app.version,
-        "service": app.title
-    }
-    
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-
-# Load environment variables
-load_dotenv()
-
-
-POSTGRES_HOST = os.environ.get("POSTGRES_HOST", "postgres")
-POSTGRES_PORT = os.environ.get("POSTGRES_PORT", "5432")
-POSTGRES_DB = os.environ.get("POSTGRES_DB", "postgres")
-POSTGRES_USER = os.environ.get("POSTGRES_USER", "postgres")
-POSTGRES_PASSWORD = os.environ.get("POSTGRES_PASSWORD", "postgres")
-POSTGRES_COLLECTION_NAME = os.environ.get("POSTGRES_COLLECTION_NAME", "memories")
-
-NEO4J_URI = os.environ.get("NEO4J_URI", "bolt://neo4j:7687")
-NEO4J_USERNAME = os.environ.get("NEO4J_USERNAME", "neo4j")
-NEO4J_PASSWORD = os.environ.get("NEO4J_PASSWORD", "mem0graph")
-
-MEMGRAPH_URI = os.environ.get("MEMGRAPH_URI", "bolt://localhost:7687")
-MEMGRAPH_USERNAME = os.environ.get("MEMGRAPH_USERNAME", "memgraph")
-MEMGRAPH_PASSWORD = os.environ.get("MEMGRAPH_PASSWORD", "mem0graph")
-
-OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
-HISTORY_DB_PATH = os.environ.get("HISTORY_DB_PATH", "/app/history/history.db")
-
-# Embedder settings (switchable by .env)
-EMBEDDER_PROVIDER = os.environ.get("EMBEDDER_PROVIDER", "openai")
-EMBEDDER_MODEL = os.environ.get("EMBEDDER_MODEL", "text-embedding-3-small")
-OLLAMA_HOST = os.environ.get("OLLAMA_HOST")  # only used if provider=ollama
-
-
-DEFAULT_CONFIG = {
-    "version": "v1.1",
-    "vector_store": {
-        "provider": "pgvector",
-        "config": {
-            "host": POSTGRES_HOST,
-            "port": int(POSTGRES_PORT),
-            "dbname": POSTGRES_DB,
-            "user": POSTGRES_USER,
-            "password": POSTGRES_PASSWORD,
-            "collection_name": POSTGRES_COLLECTION_NAME,
-        },
-    },
-    "graph_store": {
-        "provider": "neo4j",
-        "config": {"url": NEO4J_URI, "username": NEO4J_USERNAME, "password": NEO4J_PASSWORD},
-    },
-    "llm": {
-    "provider": os.getenv("LLM_PROVIDER", "ollama"),
-    "config": {
-        "model": os.getenv("LLM_MODEL", "qwen2.5:7b-instruct-q4_K_M"),
-        "ollama_base_url": os.getenv("LLM_API_BASE") or os.getenv("OLLAMA_BASE_URL"),
-        "temperature": float(os.getenv("LLM_TEMPERATURE", "0.2")),
-      },
-    },
-    "embedder": {
-    "provider": EMBEDDER_PROVIDER,
-    "config": {
-        "model": EMBEDDER_MODEL,
-        "embedding_dims": int(os.environ.get("EMBEDDING_DIMS", "1536")),
-        "openai_base_url": os.getenv("OPENAI_BASE_URL"),
-        "api_key": OPENAI_API_KEY
-       },
-    },
-    "history_db_path": HISTORY_DB_PATH,
-}
-
-import time
-
-print(">>> Embedder config:", DEFAULT_CONFIG["embedder"])
-
-# Wait for Neo4j connection before creating Memory instance
-for attempt in range(10):  # try for about 50 seconds total
-    try:
-        MEMORY_INSTANCE = Memory.from_config(DEFAULT_CONFIG)
-        print(f"✅ Connected to Neo4j on attempt {attempt + 1}")
-        break
-    except Exception as e:
-        print(f"⏳ Waiting for Neo4j (attempt {attempt + 1}/10): {e}")
-        time.sleep(5)
-else:
-    raise RuntimeError("❌ Could not connect to Neo4j after 10 attempts")
-
-class Message(BaseModel):
-    role: str = Field(..., description="Role of the message (user or assistant).")
-    content: str = Field(..., description="Message content.")
-
-
-class MemoryCreate(BaseModel):
-    messages: List[Message] = Field(..., description="List of messages to store.")
-    user_id: Optional[str] = None
-    agent_id: Optional[str] = None
-    run_id: Optional[str] = None
-    metadata: Optional[Dict[str, Any]] = None
-
-
-class SearchRequest(BaseModel):
-    query: str = Field(..., description="Search query.")
-    user_id: Optional[str] = None
-    run_id: Optional[str] = None
-    agent_id: Optional[str] = None
-    filters: Optional[Dict[str, Any]] = None
-
-
-@app.post("/configure", summary="Configure Mem0")
-def set_config(config: Dict[str, Any]):
-    """Set memory configuration."""
-    global MEMORY_INSTANCE
-    MEMORY_INSTANCE = Memory.from_config(config)
-    return {"message": "Configuration set successfully"}
-
-
-@app.post("/memories", summary="Create memories")
-def add_memory(memory_create: MemoryCreate):
-    """Store new memories."""
-    if not any([memory_create.user_id, memory_create.agent_id, memory_create.run_id]):
-        raise HTTPException(status_code=400, detail="At least one identifier (user_id, agent_id, run_id) is required.")
-
-    params = {k: v for k, v in memory_create.model_dump().items() if v is not None and k != "messages"}
-    try:
-        response = MEMORY_INSTANCE.add(messages=[m.model_dump() for m in memory_create.messages], **params)
-        return JSONResponse(content=response)
-    except Exception as e:
-        logging.exception("Error in add_memory:")  # This will log the full traceback
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/memories", summary="Get memories")
-def get_all_memories(
-    user_id: Optional[str] = None,
-    run_id: Optional[str] = None,
-    agent_id: Optional[str] = None,
-):
-    """Retrieve stored memories."""
-    if not any([user_id, run_id, agent_id]):
-        raise HTTPException(status_code=400, detail="At least one identifier is required.")
-    try:
-        params = {
-            k: v for k, v in {"user_id": user_id, "run_id": run_id, "agent_id": agent_id}.items() if v is not None
-        }
-        return MEMORY_INSTANCE.get_all(**params)
-    except Exception as e:
-        logging.exception("Error in get_all_memories:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/memories/{memory_id}", summary="Get a memory")
-def get_memory(memory_id: str):
-    """Retrieve a specific memory by ID."""
-    try:
-        return MEMORY_INSTANCE.get(memory_id)
-    except Exception as e:
-        logging.exception("Error in get_memory:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/search", summary="Search memories")
-def search_memories(search_req: SearchRequest):
-    """Search for memories based on a query."""
-    try:
-        params = {k: v for k, v in search_req.model_dump().items() if v is not None and k != "query"}
-        return MEMORY_INSTANCE.search(query=search_req.query, **params)
-    except Exception as e:
-        logging.exception("Error in search_memories:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.put("/memories/{memory_id}", summary="Update a memory")
-def update_memory(memory_id: str, updated_memory: Dict[str, Any]):
-    """Update an existing memory with new content.
-    
-    Args:
-        memory_id (str): ID of the memory to update
-        updated_memory (str): New content to update the memory with
-        
-    Returns:
-        dict: Success message indicating the memory was updated
-    """
-    try:
-        return MEMORY_INSTANCE.update(memory_id=memory_id, data=updated_memory)
-    except Exception as e:
-        logging.exception("Error in update_memory:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/memories/{memory_id}/history", summary="Get memory history")
-def memory_history(memory_id: str):
-    """Retrieve memory history."""
-    try:
-        return MEMORY_INSTANCE.history(memory_id=memory_id)
-    except Exception as e:
-        logging.exception("Error in memory_history:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.delete("/memories/{memory_id}", summary="Delete a memory")
-def delete_memory(memory_id: str):
-    """Delete a specific memory by ID."""
-    try:
-        MEMORY_INSTANCE.delete(memory_id=memory_id)
-        return {"message": "Memory deleted successfully"}
-    except Exception as e:
-        logging.exception("Error in delete_memory:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.delete("/memories", summary="Delete all memories")
-def delete_all_memories(
-    user_id: Optional[str] = None,
-    run_id: Optional[str] = None,
-    agent_id: Optional[str] = None,
-):
-    """Delete all memories for a given identifier."""
-    if not any([user_id, run_id, agent_id]):
-        raise HTTPException(status_code=400, detail="At least one identifier is required.")
-    try:
-        params = {
-            k: v for k, v in {"user_id": user_id, "run_id": run_id, "agent_id": agent_id}.items() if v is not None
-        }
-        MEMORY_INSTANCE.delete_all(**params)
-        return {"message": "All relevant memories deleted"}
-    except Exception as e:
-        logging.exception("Error in delete_all_memories:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/reset", summary="Reset all memories")
-def reset_memory():
-    """Completely reset stored memories."""
-    try:
-        MEMORY_INSTANCE.reset()
-        return {"message": "All memories reset"}
-    except Exception as e:
-        logging.exception("Error in reset_memory:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/", summary="Redirect to the OpenAPI documentation", include_in_schema=False)
-def home():
-    """Redirect to the OpenAPI documentation."""
-    return RedirectResponse(url="/docs")

neomem/_archive/old_servers/main_dev.py

@@ -1,273 +0,0 @@
-import logging
-import os
-from typing import Any, Dict, List, Optional
-
-from dotenv import load_dotenv
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import JSONResponse, RedirectResponse
-from pydantic import BaseModel, Field
-
-from neomem import Memory
-
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-
-# Load environment variables
-load_dotenv()
-
-
-POSTGRES_HOST = os.environ.get("POSTGRES_HOST", "postgres")
-POSTGRES_PORT = os.environ.get("POSTGRES_PORT", "5432")
-POSTGRES_DB = os.environ.get("POSTGRES_DB", "postgres")
-POSTGRES_USER = os.environ.get("POSTGRES_USER", "postgres")
-POSTGRES_PASSWORD = os.environ.get("POSTGRES_PASSWORD", "postgres")
-POSTGRES_COLLECTION_NAME = os.environ.get("POSTGRES_COLLECTION_NAME", "memories")
-
-NEO4J_URI = os.environ.get("NEO4J_URI", "bolt://neo4j:7687")
-NEO4J_USERNAME = os.environ.get("NEO4J_USERNAME", "neo4j")
-NEO4J_PASSWORD = os.environ.get("NEO4J_PASSWORD", "neomemgraph")
-
-MEMGRAPH_URI = os.environ.get("MEMGRAPH_URI", "bolt://localhost:7687")
-MEMGRAPH_USERNAME = os.environ.get("MEMGRAPH_USERNAME", "memgraph")
-MEMGRAPH_PASSWORD = os.environ.get("MEMGRAPH_PASSWORD", "neomemgraph")
-
-OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
-HISTORY_DB_PATH = os.environ.get("HISTORY_DB_PATH", "/app/history/history.db")
-
-# Embedder settings (switchable by .env)
-EMBEDDER_PROVIDER = os.environ.get("EMBEDDER_PROVIDER", "openai")
-EMBEDDER_MODEL = os.environ.get("EMBEDDER_MODEL", "text-embedding-3-small")
-OLLAMA_HOST = os.environ.get("OLLAMA_HOST")  # only used if provider=ollama
-
-
-DEFAULT_CONFIG = {
-    "version": "v1.1",
-    "vector_store": {
-        "provider": "pgvector",
-        "config": {
-            "host": POSTGRES_HOST,
-            "port": int(POSTGRES_PORT),
-            "dbname": POSTGRES_DB,
-            "user": POSTGRES_USER,
-            "password": POSTGRES_PASSWORD,
-            "collection_name": POSTGRES_COLLECTION_NAME,
-        },
-    },
-    "graph_store": {
-        "provider": "neo4j",
-        "config": {"url": NEO4J_URI, "username": NEO4J_USERNAME, "password": NEO4J_PASSWORD},
-    },
-    "llm": {
-    "provider": os.getenv("LLM_PROVIDER", "ollama"),
-    "config": {
-        "model": os.getenv("LLM_MODEL", "qwen2.5:7b-instruct-q4_K_M"),
-        "ollama_base_url": os.getenv("LLM_API_BASE") or os.getenv("OLLAMA_BASE_URL"),
-        "temperature": float(os.getenv("LLM_TEMPERATURE", "0.2")),
-      },
-    },
-    "embedder": {
-    "provider": EMBEDDER_PROVIDER,
-    "config": {
-        "model": EMBEDDER_MODEL,
-        "embedding_dims": int(os.environ.get("EMBEDDING_DIMS", "1536")),
-        "openai_base_url": os.getenv("OPENAI_BASE_URL"),
-        "api_key": OPENAI_API_KEY
-       },
-    },
-    "history_db_path": HISTORY_DB_PATH,
-}
-
-import time
-from fastapi import FastAPI
-
-# single app instance
-app = FastAPI(
-    title="NEOMEM REST APIs",
-    description="A REST API for managing and searching memories for your AI Agents and Apps.",
-    version="0.2.0",
-)
-
-start_time = time.time()
-
-@app.get("/health")
-def health_check():
-    uptime = round(time.time() - start_time, 1)
-    return {
-        "status": "ok",
-        "service": "NEOMEM",
-        "version": DEFAULT_CONFIG.get("version", "unknown"),
-        "uptime_seconds": uptime,
-        "message": "API reachable"
-    }
-
-print(">>> Embedder config:", DEFAULT_CONFIG["embedder"])
-
-# Wait for Neo4j connection before creating Memory instance
-for attempt in range(10):  # try for about 50 seconds total
-    try:
-        MEMORY_INSTANCE = Memory.from_config(DEFAULT_CONFIG)
-        print(f"✅ Connected to Neo4j on attempt {attempt + 1}")
-        break
-    except Exception as e:
-        print(f"⏳ Waiting for Neo4j (attempt {attempt + 1}/10): {e}")
-        time.sleep(5)
-else:
-    raise RuntimeError("❌ Could not connect to Neo4j after 10 attempts")
-
-class Message(BaseModel):
-    role: str = Field(..., description="Role of the message (user or assistant).")
-    content: str = Field(..., description="Message content.")
-
-
-class MemoryCreate(BaseModel):
-    messages: List[Message] = Field(..., description="List of messages to store.")
-    user_id: Optional[str] = None
-    agent_id: Optional[str] = None
-    run_id: Optional[str] = None
-    metadata: Optional[Dict[str, Any]] = None
-
-
-class SearchRequest(BaseModel):
-    query: str = Field(..., description="Search query.")
-    user_id: Optional[str] = None
-    run_id: Optional[str] = None
-    agent_id: Optional[str] = None
-    filters: Optional[Dict[str, Any]] = None
-
-
-@app.post("/configure", summary="Configure NeoMem")
-def set_config(config: Dict[str, Any]):
-    """Set memory configuration."""
-    global MEMORY_INSTANCE
-    MEMORY_INSTANCE = Memory.from_config(config)
-    return {"message": "Configuration set successfully"}
-
-
-@app.post("/memories", summary="Create memories")
-def add_memory(memory_create: MemoryCreate):
-    """Store new memories."""
-    if not any([memory_create.user_id, memory_create.agent_id, memory_create.run_id]):
-        raise HTTPException(status_code=400, detail="At least one identifier (user_id, agent_id, run_id) is required.")
-
-    params = {k: v for k, v in memory_create.model_dump().items() if v is not None and k != "messages"}
-    try:
-        response = MEMORY_INSTANCE.add(messages=[m.model_dump() for m in memory_create.messages], **params)
-        return JSONResponse(content=response)
-    except Exception as e:
-        logging.exception("Error in add_memory:")  # This will log the full traceback
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/memories", summary="Get memories")
-def get_all_memories(
-    user_id: Optional[str] = None,
-    run_id: Optional[str] = None,
-    agent_id: Optional[str] = None,
-):
-    """Retrieve stored memories."""
-    if not any([user_id, run_id, agent_id]):
-        raise HTTPException(status_code=400, detail="At least one identifier is required.")
-    try:
-        params = {
-            k: v for k, v in {"user_id": user_id, "run_id": run_id, "agent_id": agent_id}.items() if v is not None
-        }
-        return MEMORY_INSTANCE.get_all(**params)
-    except Exception as e:
-        logging.exception("Error in get_all_memories:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/memories/{memory_id}", summary="Get a memory")
-def get_memory(memory_id: str):
-    """Retrieve a specific memory by ID."""
-    try:
-        return MEMORY_INSTANCE.get(memory_id)
-    except Exception as e:
-        logging.exception("Error in get_memory:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/search", summary="Search memories")
-def search_memories(search_req: SearchRequest):
-    """Search for memories based on a query."""
-    try:
-        params = {k: v for k, v in search_req.model_dump().items() if v is not None and k != "query"}
-        return MEMORY_INSTANCE.search(query=search_req.query, **params)
-    except Exception as e:
-        logging.exception("Error in search_memories:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.put("/memories/{memory_id}", summary="Update a memory")
-def update_memory(memory_id: str, updated_memory: Dict[str, Any]):
-    """Update an existing memory with new content.
-    
-    Args:
-        memory_id (str): ID of the memory to update
-        updated_memory (str): New content to update the memory with
-        
-    Returns:
-        dict: Success message indicating the memory was updated
-    """
-    try:
-        return MEMORY_INSTANCE.update(memory_id=memory_id, data=updated_memory)
-    except Exception as e:
-        logging.exception("Error in update_memory:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/memories/{memory_id}/history", summary="Get memory history")
-def memory_history(memory_id: str):
-    """Retrieve memory history."""
-    try:
-        return MEMORY_INSTANCE.history(memory_id=memory_id)
-    except Exception as e:
-        logging.exception("Error in memory_history:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.delete("/memories/{memory_id}", summary="Delete a memory")
-def delete_memory(memory_id: str):
-    """Delete a specific memory by ID."""
-    try:
-        MEMORY_INSTANCE.delete(memory_id=memory_id)
-        return {"message": "Memory deleted successfully"}
-    except Exception as e:
-        logging.exception("Error in delete_memory:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.delete("/memories", summary="Delete all memories")
-def delete_all_memories(
-    user_id: Optional[str] = None,
-    run_id: Optional[str] = None,
-    agent_id: Optional[str] = None,
-):
-    """Delete all memories for a given identifier."""
-    if not any([user_id, run_id, agent_id]):
-        raise HTTPException(status_code=400, detail="At least one identifier is required.")
-    try:
-        params = {
-            k: v for k, v in {"user_id": user_id, "run_id": run_id, "agent_id": agent_id}.items() if v is not None
-        }
-        MEMORY_INSTANCE.delete_all(**params)
-        return {"message": "All relevant memories deleted"}
-    except Exception as e:
-        logging.exception("Error in delete_all_memories:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/reset", summary="Reset all memories")
-def reset_memory():
-    """Completely reset stored memories."""
-    try:
-        MEMORY_INSTANCE.reset()
-        return {"message": "All memories reset"}
-    except Exception as e:
-        logging.exception("Error in reset_memory:")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/", summary="Redirect to the OpenAPI documentation", include_in_schema=False)
-def home():
-    """Redirect to the OpenAPI documentation."""
-    return RedirectResponse(url="/docs")

neomem/docker-compose.yml

@@ -1,66 +0,0 @@
-services:
-  neomem-postgres:
-    image: ankane/pgvector:v0.5.1
-    container_name: neomem-postgres
-    restart: unless-stopped
-    environment:
-      POSTGRES_USER: neomem
-      POSTGRES_PASSWORD: neomempass
-      POSTGRES_DB: neomem
-    volumes:
-      - postgres_data:/var/lib/postgresql/data
-    ports:
-      - "5432:5432"
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U neomem -d neomem || exit 1"]
-      interval: 5s
-      timeout: 5s
-      retries: 10
-    networks:
-      - lyra-net
-
-  neomem-neo4j:
-    image: neo4j:5
-    container_name: neomem-neo4j
-    restart: unless-stopped
-    environment:
-      NEO4J_AUTH: neo4j/neomemgraph
-    ports:
-      - "7474:7474"
-      - "7687:7687"
-    volumes:
-      - neo4j_data:/data
-    healthcheck:
-      test: ["CMD-SHELL", "cypher-shell -u neo4j -p neomemgraph 'RETURN 1' || exit 1"]
-      interval: 10s
-      timeout: 10s
-      retries: 10
-    networks:
-      - lyra-net
-
-  neomem-api:
-    build: .
-    image: lyra-neomem:latest
-    container_name: neomem-api
-    restart: unless-stopped
-    ports:
-      - "7077:7077"
-    env_file:
-      - .env
-    volumes:
-      - ./neomem_history:/app/history
-    depends_on:
-      neomem-postgres:
-        condition: service_healthy
-      neomem-neo4j:
-        condition: service_healthy
-    networks:
-      - lyra-net
-
-volumes:
-  postgres_data:
-  neo4j_data:
-
-networks:
-  lyra-net:
-    external: true

neomem/neomem/LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [2023] [Taranjeet Singh]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

neomem/neomem/__init__.py

@@ -1,18 +0,0 @@
-"""
-Lyra-NeoMem
-Vector-centric memory subsystem forked from Mem0 OSS.
-"""
-
-import importlib.metadata
-
-# Package identity
-try:
-    __version__ = importlib.metadata.version("lyra-neomem")
-except importlib.metadata.PackageNotFoundError:
-    __version__ = "0.1.0"
-
-# Expose primary classes
-from neomem.memory.main import Memory, AsyncMemory  # noqa: F401
-from neomem.client.main import MemoryClient, AsyncMemoryClient  # noqa: F401
-
-__all__ = ["Memory", "AsyncMemory", "MemoryClient", "AsyncMemoryClient"]

neomem/neomem/client/project.py

@@ -1,931 +0,0 @@
-import logging
-from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
-
-import httpx
-from pydantic import BaseModel, ConfigDict, Field
-
-from neomem.client.utils import api_error_handler
-from neomem.memory.telemetry import capture_client_event
-# Exception classes are referenced in docstrings only
-
-logger = logging.getLogger(__name__)
-
-
-class ProjectConfig(BaseModel):
-    """
-    Configuration for project management operations.
-    """
-
-    org_id: Optional[str] = Field(default=None, description="Organization ID")
-    project_id: Optional[str] = Field(default=None, description="Project ID")
-    user_email: Optional[str] = Field(default=None, description="User email")
-
-    model_config = ConfigDict(validate_assignment=True, extra="forbid")
-
-
-class BaseProject(ABC):
-    """
-    Abstract base class for project management operations.
-    """
-
-    def __init__(
-        self,
-        client: Any,
-        config: Optional[ProjectConfig] = None,
-        org_id: Optional[str] = None,
-        project_id: Optional[str] = None,
-        user_email: Optional[str] = None,
-    ):
-        """
-        Initialize the project manager.
-
-        Args:
-            client: HTTP client instance
-            config: Project manager configuration
-            org_id: Organization ID
-            project_id: Project ID
-            user_email: User email
-        """
-        self._client = client
-
-        # Handle config initialization
-        if config is not None:
-            self.config = config
-        else:
-            # Create config from parameters
-            self.config = ProjectConfig(org_id=org_id, project_id=project_id, user_email=user_email)
-
-    @property
-    def org_id(self) -> Optional[str]:
-        """Get the organization ID."""
-        return self.config.org_id
-
-    @property
-    def project_id(self) -> Optional[str]:
-        """Get the project ID."""
-        return self.config.project_id
-
-    @property
-    def user_email(self) -> Optional[str]:
-        """Get the user email."""
-        return self.config.user_email
-
-    def _validate_org_project(self) -> None:
-        """
-        Validate that both org_id and project_id are set.
-
-        Raises:
-            ValueError: If org_id or project_id are not set.
-        """
-        if not (self.config.org_id and self.config.project_id):
-            raise ValueError("org_id and project_id must be set to access project operations")
-
-    def _prepare_params(self, kwargs: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """
-        Prepare query parameters for API requests.
-
-        Args:
-            kwargs: Additional keyword arguments.
-
-        Returns:
-            Dictionary containing prepared parameters.
-
-        Raises:
-            ValueError: If org_id or project_id validation fails.
-        """
-        if kwargs is None:
-            kwargs = {}
-
-        # Add org_id and project_id if available
-        if self.config.org_id and self.config.project_id:
-            kwargs["org_id"] = self.config.org_id
-            kwargs["project_id"] = self.config.project_id
-        elif self.config.org_id or self.config.project_id:
-            raise ValueError("Please provide both org_id and project_id")
-
-        return {k: v for k, v in kwargs.items() if v is not None}
-
-    def _prepare_org_params(self, kwargs: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """
-        Prepare query parameters for organization-level API requests.
-
-        Args:
-            kwargs: Additional keyword arguments.
-
-        Returns:
-            Dictionary containing prepared parameters.
-
-        Raises:
-            ValueError: If org_id is not provided.
-        """
-        if kwargs is None:
-            kwargs = {}
-
-        # Add org_id if available
-        if self.config.org_id:
-            kwargs["org_id"] = self.config.org_id
-        else:
-            raise ValueError("org_id must be set for organization-level operations")
-
-        return {k: v for k, v in kwargs.items() if v is not None}
-
-    @abstractmethod
-    def get(self, fields: Optional[List[str]] = None) -> Dict[str, Any]:
-        """
-        Get project details.
-
-        Args:
-            fields: List of fields to retrieve
-
-        Returns:
-            Dictionary containing the requested project fields.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        pass
-
-    @abstractmethod
-    def create(self, name: str, description: Optional[str] = None) -> Dict[str, Any]:
-        """
-        Create a new project within the organization.
-
-        Args:
-            name: Name of the project to be created
-            description: Optional description for the project
-
-        Returns:
-            Dictionary containing the created project details.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id is not set.
-        """
-        pass
-
-    @abstractmethod
-    def update(
-        self,
-        custom_instructions: Optional[str] = None,
-        custom_categories: Optional[List[str]] = None,
-        retrieval_criteria: Optional[List[Dict[str, Any]]] = None,
-        enable_graph: Optional[bool] = None,
-    ) -> Dict[str, Any]:
-        """
-        Update project settings.
-
-        Args:
-            custom_instructions: New instructions for the project
-            custom_categories: New categories for the project
-            retrieval_criteria: New retrieval criteria for the project
-            enable_graph: Enable or disable the graph for the project
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        pass
-
-    @abstractmethod
-    def delete(self) -> Dict[str, Any]:
-        """
-        Delete the current project and its related data.
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        pass
-
-    @abstractmethod
-    def get_members(self) -> Dict[str, Any]:
-        """
-        Get all members of the current project.
-
-        Returns:
-            Dictionary containing the list of project members.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        pass
-
-    @abstractmethod
-    def add_member(self, email: str, role: str = "READER") -> Dict[str, Any]:
-        """
-        Add a new member to the current project.
-
-        Args:
-            email: Email address of the user to add
-            role: Role to assign ("READER" or "OWNER")
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        pass
-
-    @abstractmethod
-    def update_member(self, email: str, role: str) -> Dict[str, Any]:
-        """
-        Update a member's role in the current project.
-
-        Args:
-            email: Email address of the user to update
-            role: New role to assign ("READER" or "OWNER")
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        pass
-
-    @abstractmethod
-    def remove_member(self, email: str) -> Dict[str, Any]:
-        """
-        Remove a member from the current project.
-
-        Args:
-            email: Email address of the user to remove
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        pass
-
-
-class Project(BaseProject):
-    """
-    Synchronous project management operations.
-    """
-
-    def __init__(
-        self,
-        client: httpx.Client,
-        config: Optional[ProjectConfig] = None,
-        org_id: Optional[str] = None,
-        project_id: Optional[str] = None,
-        user_email: Optional[str] = None,
-    ):
-        """
-        Initialize the synchronous project manager.
-
-        Args:
-            client: HTTP client instance
-            config: Project manager configuration
-            org_id: Organization ID
-            project_id: Project ID
-            user_email: User email
-        """
-        super().__init__(client, config, org_id, project_id, user_email)
-        self._validate_org_project()
-
-    @api_error_handler
-    def get(self, fields: Optional[List[str]] = None) -> Dict[str, Any]:
-        """
-        Get project details.
-
-        Args:
-            fields: List of fields to retrieve
-
-        Returns:
-            Dictionary containing the requested project fields.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        params = self._prepare_params({"fields": fields})
-        response = self._client.get(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/",
-            params=params,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.get",
-            self,
-            {"fields": fields, "sync_type": "sync"},
-        )
-        return response.json()
-
-    @api_error_handler
-    def create(self, name: str, description: Optional[str] = None) -> Dict[str, Any]:
-        """
-        Create a new project within the organization.
-
-        Args:
-            name: Name of the project to be created
-            description: Optional description for the project
-
-        Returns:
-            Dictionary containing the created project details.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id is not set.
-        """
-        if not self.config.org_id:
-            raise ValueError("org_id must be set to create a project")
-
-        payload = {"name": name}
-        if description is not None:
-            payload["description"] = description
-
-        response = self._client.post(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/",
-            json=payload,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.create",
-            self,
-            {"name": name, "description": description, "sync_type": "sync"},
-        )
-        return response.json()
-
-    @api_error_handler
-    def update(
-        self,
-        custom_instructions: Optional[str] = None,
-        custom_categories: Optional[List[str]] = None,
-        retrieval_criteria: Optional[List[Dict[str, Any]]] = None,
-        enable_graph: Optional[bool] = None,
-    ) -> Dict[str, Any]:
-        """
-        Update project settings.
-
-        Args:
-            custom_instructions: New instructions for the project
-            custom_categories: New categories for the project
-            retrieval_criteria: New retrieval criteria for the project
-            enable_graph: Enable or disable the graph for the project
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        if (
-            custom_instructions is None
-            and custom_categories is None
-            and retrieval_criteria is None
-            and enable_graph is None
-        ):
-            raise ValueError(
-                "At least one parameter must be provided for update: "
-                "custom_instructions, custom_categories, retrieval_criteria, "
-                "enable_graph"
-            )
-
-        payload = self._prepare_params(
-            {
-                "custom_instructions": custom_instructions,
-                "custom_categories": custom_categories,
-                "retrieval_criteria": retrieval_criteria,
-                "enable_graph": enable_graph,
-            }
-        )
-        response = self._client.patch(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/",
-            json=payload,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.update",
-            self,
-            {
-                "custom_instructions": custom_instructions,
-                "custom_categories": custom_categories,
-                "retrieval_criteria": retrieval_criteria,
-                "enable_graph": enable_graph,
-                "sync_type": "sync",
-            },
-        )
-        return response.json()
-
-    @api_error_handler
-    def delete(self) -> Dict[str, Any]:
-        """
-        Delete the current project and its related data.
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        response = self._client.delete(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/",
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.delete",
-            self,
-            {"sync_type": "sync"},
-        )
-        return response.json()
-
-    @api_error_handler
-    def get_members(self) -> Dict[str, Any]:
-        """
-        Get all members of the current project.
-
-        Returns:
-            Dictionary containing the list of project members.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        response = self._client.get(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/members/",
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.get_members",
-            self,
-            {"sync_type": "sync"},
-        )
-        return response.json()
-
-    @api_error_handler
-    def add_member(self, email: str, role: str = "READER") -> Dict[str, Any]:
-        """
-        Add a new member to the current project.
-
-        Args:
-            email: Email address of the user to add
-            role: Role to assign ("READER" or "OWNER")
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        if role not in ["READER", "OWNER"]:
-            raise ValueError("Role must be either 'READER' or 'OWNER'")
-
-        payload = {"email": email, "role": role}
-
-        response = self._client.post(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/members/",
-            json=payload,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.add_member",
-            self,
-            {"email": email, "role": role, "sync_type": "sync"},
-        )
-        return response.json()
-
-    @api_error_handler
-    def update_member(self, email: str, role: str) -> Dict[str, Any]:
-        """
-        Update a member's role in the current project.
-
-        Args:
-            email: Email address of the user to update
-            role: New role to assign ("READER" or "OWNER")
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        if role not in ["READER", "OWNER"]:
-            raise ValueError("Role must be either 'READER' or 'OWNER'")
-
-        payload = {"email": email, "role": role}
-
-        response = self._client.put(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/members/",
-            json=payload,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.update_member",
-            self,
-            {"email": email, "role": role, "sync_type": "sync"},
-        )
-        return response.json()
-
-    @api_error_handler
-    def remove_member(self, email: str) -> Dict[str, Any]:
-        """
-        Remove a member from the current project.
-
-        Args:
-            email: Email address of the user to remove
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        params = {"email": email}
-
-        response = self._client.delete(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/members/",
-            params=params,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.remove_member",
-            self,
-            {"email": email, "sync_type": "sync"},
-        )
-        return response.json()
-
-
-class AsyncProject(BaseProject):
-    """
-    Asynchronous project management operations.
-    """
-
-    def __init__(
-        self,
-        client: httpx.AsyncClient,
-        config: Optional[ProjectConfig] = None,
-        org_id: Optional[str] = None,
-        project_id: Optional[str] = None,
-        user_email: Optional[str] = None,
-    ):
-        """
-        Initialize the asynchronous project manager.
-
-        Args:
-            client: HTTP client instance
-            config: Project manager configuration
-            org_id: Organization ID
-            project_id: Project ID
-            user_email: User email
-        """
-        super().__init__(client, config, org_id, project_id, user_email)
-        self._validate_org_project()
-
-    @api_error_handler
-    async def get(self, fields: Optional[List[str]] = None) -> Dict[str, Any]:
-        """
-        Get project details.
-
-        Args:
-            fields: List of fields to retrieve
-
-        Returns:
-            Dictionary containing the requested project fields.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        params = self._prepare_params({"fields": fields})
-        response = await self._client.get(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/",
-            params=params,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.get",
-            self,
-            {"fields": fields, "sync_type": "async"},
-        )
-        return response.json()
-
-    @api_error_handler
-    async def create(self, name: str, description: Optional[str] = None) -> Dict[str, Any]:
-        """
-        Create a new project within the organization.
-
-        Args:
-            name: Name of the project to be created
-            description: Optional description for the project
-
-        Returns:
-            Dictionary containing the created project details.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id is not set.
-        """
-        if not self.config.org_id:
-            raise ValueError("org_id must be set to create a project")
-
-        payload = {"name": name}
-        if description is not None:
-            payload["description"] = description
-
-        response = await self._client.post(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/",
-            json=payload,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.create",
-            self,
-            {"name": name, "description": description, "sync_type": "async"},
-        )
-        return response.json()
-
-    @api_error_handler
-    async def update(
-        self,
-        custom_instructions: Optional[str] = None,
-        custom_categories: Optional[List[str]] = None,
-        retrieval_criteria: Optional[List[Dict[str, Any]]] = None,
-        enable_graph: Optional[bool] = None,
-    ) -> Dict[str, Any]:
-        """
-        Update project settings.
-
-        Args:
-            custom_instructions: New instructions for the project
-            custom_categories: New categories for the project
-            retrieval_criteria: New retrieval criteria for the project
-            enable_graph: Enable or disable the graph for the project
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        if (
-            custom_instructions is None
-            and custom_categories is None
-            and retrieval_criteria is None
-            and enable_graph is None
-        ):
-            raise ValueError(
-                "At least one parameter must be provided for update: "
-                "custom_instructions, custom_categories, retrieval_criteria, "
-                "enable_graph"
-            )
-
-        payload = self._prepare_params(
-            {
-                "custom_instructions": custom_instructions,
-                "custom_categories": custom_categories,
-                "retrieval_criteria": retrieval_criteria,
-                "enable_graph": enable_graph,
-            }
-        )
-        response = await self._client.patch(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/",
-            json=payload,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.update",
-            self,
-            {
-                "custom_instructions": custom_instructions,
-                "custom_categories": custom_categories,
-                "retrieval_criteria": retrieval_criteria,
-                "enable_graph": enable_graph,
-                "sync_type": "async",
-            },
-        )
-        return response.json()
-
-    @api_error_handler
-    async def delete(self) -> Dict[str, Any]:
-        """
-        Delete the current project and its related data.
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        response = await self._client.delete(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/",
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.delete",
-            self,
-            {"sync_type": "async"},
-        )
-        return response.json()
-
-    @api_error_handler
-    async def get_members(self) -> Dict[str, Any]:
-        """
-        Get all members of the current project.
-
-        Returns:
-            Dictionary containing the list of project members.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        response = await self._client.get(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/members/",
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.get_members",
-            self,
-            {"sync_type": "async"},
-        )
-        return response.json()
-
-    @api_error_handler
-    async def add_member(self, email: str, role: str = "READER") -> Dict[str, Any]:
-        """
-        Add a new member to the current project.
-
-        Args:
-            email: Email address of the user to add
-            role: Role to assign ("READER" or "OWNER")
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        if role not in ["READER", "OWNER"]:
-            raise ValueError("Role must be either 'READER' or 'OWNER'")
-
-        payload = {"email": email, "role": role}
-
-        response = await self._client.post(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/members/",
-            json=payload,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.add_member",
-            self,
-            {"email": email, "role": role, "sync_type": "async"},
-        )
-        return response.json()
-
-    @api_error_handler
-    async def update_member(self, email: str, role: str) -> Dict[str, Any]:
-        """
-        Update a member's role in the current project.
-
-        Args:
-            email: Email address of the user to update
-            role: New role to assign ("READER" or "OWNER")
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        if role not in ["READER", "OWNER"]:
-            raise ValueError("Role must be either 'READER' or 'OWNER'")
-
-        payload = {"email": email, "role": role}
-
-        response = await self._client.put(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/members/",
-            json=payload,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.update_member",
-            self,
-            {"email": email, "role": role, "sync_type": "async"},
-        )
-        return response.json()
-
-    @api_error_handler
-    async def remove_member(self, email: str) -> Dict[str, Any]:
-        """
-        Remove a member from the current project.
-
-        Args:
-            email: Email address of the user to remove
-
-        Returns:
-            Dictionary containing the API response.
-
-        Raises:
-            ValidationError: If the input data is invalid.
-            AuthenticationError: If authentication fails.
-            RateLimitError: If rate limits are exceeded.
-            NetworkError: If network connectivity issues occur.
-            ValueError: If org_id or project_id are not set.
-        """
-        params = {"email": email}
-
-        response = await self._client.delete(
-            f"/api/v1/orgs/organizations/{self.config.org_id}/projects/{self.config.project_id}/members/",
-            params=params,
-        )
-        response.raise_for_status()
-        capture_client_event(
-            "client.project.remove_member",
-            self,
-            {"email": email, "sync_type": "async"},
-        )
-        return response.json()

neomem/neomem/client/utils.py

@@ -1,115 +0,0 @@
-import json
-import logging
-import httpx
-
-from neomem.exceptions import (
-    NetworkError,
-    create_exception_from_response,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class APIError(Exception):
-    """Exception raised for errors in the API.
-    
-    Deprecated: Use specific exception classes from neomem.exceptions instead.
-    This class is maintained for backward compatibility.
-    """
-
-    pass
-
-
-def api_error_handler(func):
-    """Decorator to handle API errors consistently.
-    
-    This decorator catches HTTP and request errors and converts them to
-    appropriate structured exception classes with detailed error information.
-    
-    The decorator analyzes HTTP status codes and response content to create
-    the most specific exception type with helpful error messages, suggestions,
-    and debug information.
-    """
-    from functools import wraps
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except httpx.HTTPStatusError as e:
-            logger.error(f"HTTP error occurred: {e}")
-            
-            # Extract error details from response
-            response_text = ""
-            error_details = {}
-            debug_info = {
-                "status_code": e.response.status_code,
-                "url": str(e.request.url),
-                "method": e.request.method,
-            }
-            
-            try:
-                response_text = e.response.text
-                # Try to parse JSON response for additional error details
-                if e.response.headers.get("content-type", "").startswith("application/json"):
-                    error_data = json.loads(response_text)
-                    if isinstance(error_data, dict):
-                        error_details = error_data
-                        response_text = error_data.get("detail", response_text)
-            except (json.JSONDecodeError, AttributeError):
-                # Fallback to plain text response
-                pass
-            
-            # Add rate limit information if available
-            if e.response.status_code == 429:
-                retry_after = e.response.headers.get("Retry-After")
-                if retry_after:
-                    try:
-                        debug_info["retry_after"] = int(retry_after)
-                    except ValueError:
-                        pass
-                
-                # Add rate limit headers if available
-                for header in ["X-RateLimit-Limit", "X-RateLimit-Remaining", "X-RateLimit-Reset"]:
-                    value = e.response.headers.get(header)
-                    if value:
-                        debug_info[header.lower().replace("-", "_")] = value
-            
-            # Create specific exception based on status code
-            exception = create_exception_from_response(
-                status_code=e.response.status_code,
-                response_text=response_text,
-                details=error_details,
-                debug_info=debug_info,
-            )
-            
-            raise exception
-            
-        except httpx.RequestError as e:
-            logger.error(f"Request error occurred: {e}")
-            
-            # Determine the appropriate exception type based on error type
-            if isinstance(e, httpx.TimeoutException):
-                raise NetworkError(
-                    message=f"Request timed out: {str(e)}",
-                    error_code="NET_TIMEOUT",
-                    suggestion="Please check your internet connection and try again",
-                    debug_info={"error_type": "timeout", "original_error": str(e)},
-                )
-            elif isinstance(e, httpx.ConnectError):
-                raise NetworkError(
-                    message=f"Connection failed: {str(e)}",
-                    error_code="NET_CONNECT",
-                    suggestion="Please check your internet connection and try again",
-                    debug_info={"error_type": "connection", "original_error": str(e)},
-                )
-            else:
-                # Generic network error for other request errors
-                raise NetworkError(
-                    message=f"Network request failed: {str(e)}",
-                    error_code="NET_GENERIC",
-                    suggestion="Please check your internet connection and try again",
-                    debug_info={"error_type": "request", "original_error": str(e)},
-                )
-
-    return wrapper

neomem/neomem/configs/base.py

@@ -1,85 +0,0 @@
-import os
-from typing import Any, Dict, Optional
-
-from pydantic import BaseModel, Field
-
-from neomem.embeddings.configs import EmbedderConfig
-from neomem.graphs.configs import GraphStoreConfig
-from neomem.llms.configs import LlmConfig
-from neomem.vector_stores.configs import VectorStoreConfig
-
-# Set up the directory path
-home_dir = os.path.expanduser("~")
-neomem_dir = os.environ.get("NEOMEM_DIR") or os.path.join(home_dir, ".neomem")
-
-
-class MemoryItem(BaseModel):
-    id: str = Field(..., description="The unique identifier for the text data")
-    memory: str = Field(
-        ..., description="The memory deduced from the text data"
-    )  # TODO After prompt changes from platform, update this
-    hash: Optional[str] = Field(None, description="The hash of the memory")
-    # The metadata value can be anything and not just string. Fix it
-    metadata: Optional[Dict[str, Any]] = Field(None, description="Additional metadata for the text data")
-    score: Optional[float] = Field(None, description="The score associated with the text data")
-    created_at: Optional[str] = Field(None, description="The timestamp when the memory was created")
-    updated_at: Optional[str] = Field(None, description="The timestamp when the memory was updated")
-
-
-class MemoryConfig(BaseModel):
-    vector_store: VectorStoreConfig = Field(
-        description="Configuration for the vector store",
-        default_factory=VectorStoreConfig,
-    )
-    llm: LlmConfig = Field(
-        description="Configuration for the language model",
-        default_factory=LlmConfig,
-    )
-    embedder: EmbedderConfig = Field(
-        description="Configuration for the embedding model",
-        default_factory=EmbedderConfig,
-    )
-    history_db_path: str = Field(
-        description="Path to the history database",
-        default=os.path.join(neomem_dir, "history.db"),
-    )
-    graph_store: GraphStoreConfig = Field(
-        description="Configuration for the graph",
-        default_factory=GraphStoreConfig,
-    )
-    version: str = Field(
-        description="The version of the API",
-        default="v1.1",
-    )
-    custom_fact_extraction_prompt: Optional[str] = Field(
-        description="Custom prompt for the fact extraction",
-        default=None,
-    )
-    custom_update_memory_prompt: Optional[str] = Field(
-        description="Custom prompt for the update memory",
-        default=None,
-    )
-
-
-class AzureConfig(BaseModel):
-    """
-    Configuration settings for Azure.
-
-    Args:
-        api_key (str): The API key used for authenticating with the Azure service.
-        azure_deployment (str): The name of the Azure deployment.
-        azure_endpoint (str): The endpoint URL for the Azure service.
-        api_version (str): The version of the Azure API being used.
-        default_headers (Dict[str, str]): Headers to include in requests to the Azure API.
-    """
-
-    api_key: str = Field(
-        description="The API key used for authenticating with the Azure service.",
-        default=None,
-    )
-    azure_deployment: str = Field(description="The name of the Azure deployment.", default=None)
-    azure_endpoint: str = Field(description="The endpoint URL for the Azure service.", default=None)
-    api_version: str = Field(description="The version of the Azure API being used.", default=None)
-    default_headers: Optional[Dict[str, str]] = Field(
-        description="Headers to include in requests to the Azure API.", default=None
-    )

neomem/neomem/configs/embeddings/base.py

@@ -1,110 +0,0 @@
-import os
-from abc import ABC
-from typing import Dict, Optional, Union
-
-import httpx
-
-from neomem.configs.base import AzureConfig
-
-
-class BaseEmbedderConfig(ABC):
-    """
-    Config for Embeddings.
-    """
-
-    def __init__(
-        self,
-        model: Optional[str] = None,
-        api_key: Optional[str] = None,
-        embedding_dims: Optional[int] = None,
-        # Ollama specific
-        ollama_base_url: Optional[str] = None,
-        # Openai specific
-        openai_base_url: Optional[str] = None,
-        # Huggingface specific
-        model_kwargs: Optional[dict] = None,
-        huggingface_base_url: Optional[str] = None,
-        # AzureOpenAI specific
-        azure_kwargs: Optional[AzureConfig] = {},
-        http_client_proxies: Optional[Union[Dict, str]] = None,
-        # VertexAI specific
-        vertex_credentials_json: Optional[str] = None,
-        memory_add_embedding_type: Optional[str] = None,
-        memory_update_embedding_type: Optional[str] = None,
-        memory_search_embedding_type: Optional[str] = None,
-        # Gemini specific
-        output_dimensionality: Optional[str] = None,
-        # LM Studio specific
-        lmstudio_base_url: Optional[str] = "http://localhost:1234/v1",
-        # AWS Bedrock specific
-        aws_access_key_id: Optional[str] = None,
-        aws_secret_access_key: Optional[str] = None,
-        aws_region: Optional[str] = None,
-    ):
-        """
-        Initializes a configuration class instance for the Embeddings.
-
-        :param model: Embedding model to use, defaults to None
-        :type model: Optional[str], optional
-        :param api_key: API key to be use, defaults to None
-        :type api_key: Optional[str], optional
-        :param embedding_dims: The number of dimensions in the embedding, defaults to None
-        :type embedding_dims: Optional[int], optional
-        :param ollama_base_url: Base URL for the Ollama API, defaults to None
-        :type ollama_base_url: Optional[str], optional
-        :param model_kwargs: key-value arguments for the huggingface embedding model, defaults a dict inside init
-        :type model_kwargs: Optional[Dict[str, Any]], defaults a dict inside init
-        :param huggingface_base_url: Huggingface base URL to be use, defaults to None
-        :type huggingface_base_url: Optional[str], optional
-        :param openai_base_url: Openai base URL to be use, defaults to "https://api.openai.com/v1"
-        :type openai_base_url: Optional[str], optional
-        :param azure_kwargs: key-value arguments for the AzureOpenAI embedding model, defaults a dict inside init
-        :type azure_kwargs: Optional[Dict[str, Any]], defaults a dict inside init
-        :param http_client_proxies: The proxy server settings used to create self.http_client, defaults to None
-        :type http_client_proxies: Optional[Dict | str], optional
-        :param vertex_credentials_json: The path to the Vertex AI credentials JSON file, defaults to None
-        :type vertex_credentials_json: Optional[str], optional
-        :param memory_add_embedding_type: The type of embedding to use for the add memory action, defaults to None
-        :type memory_add_embedding_type: Optional[str], optional
-        :param memory_update_embedding_type: The type of embedding to use for the update memory action, defaults to None
-        :type memory_update_embedding_type: Optional[str], optional
-        :param memory_search_embedding_type: The type of embedding to use for the search memory action, defaults to None
-        :type memory_search_embedding_type: Optional[str], optional
-        :param lmstudio_base_url: LM Studio base URL to be use, defaults to "http://localhost:1234/v1"
-        :type lmstudio_base_url: Optional[str], optional
-        """
-
-        self.model = model
-        self.api_key = api_key
-        self.openai_base_url = openai_base_url
-        self.embedding_dims = embedding_dims
-
-        # AzureOpenAI specific
-        self.http_client = httpx.Client(proxies=http_client_proxies) if http_client_proxies else None
-
-        # Ollama specific
-        self.ollama_base_url = ollama_base_url
-
-        # Huggingface specific
-        self.model_kwargs = model_kwargs or {}
-        self.huggingface_base_url = huggingface_base_url
-        # AzureOpenAI specific
-        self.azure_kwargs = AzureConfig(**azure_kwargs) or {}
-
-        # VertexAI specific
-        self.vertex_credentials_json = vertex_credentials_json
-        self.memory_add_embedding_type = memory_add_embedding_type
-        self.memory_update_embedding_type = memory_update_embedding_type
-        self.memory_search_embedding_type = memory_search_embedding_type
-
-        # Gemini specific
-        self.output_dimensionality = output_dimensionality
-
-        # LM Studio specific
-        self.lmstudio_base_url = lmstudio_base_url
-
-        # AWS Bedrock specific
-        self.aws_access_key_id = aws_access_key_id
-        self.aws_secret_access_key = aws_secret_access_key
-        self.aws_region = aws_region or os.environ.get("AWS_REGION") or "us-west-2"
-

neomem/neomem/configs/enums.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-
-class MemoryType(Enum):
-    SEMANTIC = "semantic_memory"
-    EPISODIC = "episodic_memory"
-    PROCEDURAL = "procedural_memory"

neomem/neomem/configs/llms/anthropic.py

@@ -1,56 +0,0 @@
-from typing import Optional
-
-from mem0.configs.llms.base import BaseLlmConfig
-
-
-class AnthropicConfig(BaseLlmConfig):
-    """
-    Configuration class for Anthropic-specific parameters.
-    Inherits from BaseLlmConfig and adds Anthropic-specific settings.
-    """
-
-    def __init__(
-        self,
-        # Base parameters
-        model: Optional[str] = None,
-        temperature: float = 0.1,
-        api_key: Optional[str] = None,
-        max_tokens: int = 2000,
-        top_p: float = 0.1,
-        top_k: int = 1,
-        enable_vision: bool = False,
-        vision_details: Optional[str] = "auto",
-        http_client_proxies: Optional[dict] = None,
-        # Anthropic-specific parameters
-        anthropic_base_url: Optional[str] = None,
-    ):
-        """
-        Initialize Anthropic configuration.
-
-        Args:
-            model: Anthropic model to use, defaults to None
-            temperature: Controls randomness, defaults to 0.1
-            api_key: Anthropic API key, defaults to None
-            max_tokens: Maximum tokens to generate, defaults to 2000
-            top_p: Nucleus sampling parameter, defaults to 0.1
-            top_k: Top-k sampling parameter, defaults to 1
-            enable_vision: Enable vision capabilities, defaults to False
-            vision_details: Vision detail level, defaults to "auto"
-            http_client_proxies: HTTP client proxy settings, defaults to None
-            anthropic_base_url: Anthropic API base URL, defaults to None
-        """
-        # Initialize base parameters
-        super().__init__(
-            model=model,
-            temperature=temperature,
-            api_key=api_key,
-            max_tokens=max_tokens,
-            top_p=top_p,
-            top_k=top_k,
-            enable_vision=enable_vision,
-            vision_details=vision_details,
-            http_client_proxies=http_client_proxies,
-        )
-
-        # Anthropic-specific parameters
-        self.anthropic_base_url = anthropic_base_url

neomem/neomem/configs/llms/aws_bedrock.py

@@ -1,192 +0,0 @@
-import os
-from typing import Any, Dict, List, Optional
-
-from mem0.configs.llms.base import BaseLlmConfig
-
-
-class AWSBedrockConfig(BaseLlmConfig):
-    """
-    Configuration class for AWS Bedrock LLM integration.
-
-    Supports all available Bedrock models with automatic provider detection.
-    """
-
-    def __init__(
-        self,
-        model: Optional[str] = None,
-        temperature: float = 0.1,
-        max_tokens: int = 2000,
-        top_p: float = 0.9,
-        top_k: int = 1,
-        aws_access_key_id: Optional[str] = None,
-        aws_secret_access_key: Optional[str] = None,
-        aws_region: str = "",
-        aws_session_token: Optional[str] = None,
-        aws_profile: Optional[str] = None,
-        model_kwargs: Optional[Dict[str, Any]] = None,
-        **kwargs,
-    ):
-        """
-        Initialize AWS Bedrock configuration.
-
-        Args:
-            model: Bedrock model identifier (e.g., "amazon.nova-3-mini-20241119-v1:0")
-            temperature: Controls randomness (0.0 to 2.0)
-            max_tokens: Maximum tokens to generate
-            top_p: Nucleus sampling parameter (0.0 to 1.0)
-            top_k: Top-k sampling parameter (1 to 40)
-            aws_access_key_id: AWS access key (optional, uses env vars if not provided)
-            aws_secret_access_key: AWS secret key (optional, uses env vars if not provided)
-            aws_region: AWS region for Bedrock service
-            aws_session_token: AWS session token for temporary credentials
-            aws_profile: AWS profile name for credentials
-            model_kwargs: Additional model-specific parameters
-            **kwargs: Additional arguments passed to base class
-        """
-        super().__init__(
-            model=model or "anthropic.claude-3-5-sonnet-20240620-v1:0",
-            temperature=temperature,
-            max_tokens=max_tokens,
-            top_p=top_p,
-            top_k=top_k,
-            **kwargs,
-        )
-
-        self.aws_access_key_id = aws_access_key_id
-        self.aws_secret_access_key = aws_secret_access_key
-        self.aws_region = aws_region or os.getenv("AWS_REGION", "us-west-2")
-        self.aws_session_token = aws_session_token
-        self.aws_profile = aws_profile
-        self.model_kwargs = model_kwargs or {}
-
-    @property
-    def provider(self) -> str:
-        """Get the provider from the model identifier."""
-        if not self.model or "." not in self.model:
-            return "unknown"
-        return self.model.split(".")[0]
-
-    @property
-    def model_name(self) -> str:
-        """Get the model name without provider prefix."""
-        if not self.model or "." not in self.model:
-            return self.model
-        return ".".join(self.model.split(".")[1:])
-
-    def get_model_config(self) -> Dict[str, Any]:
-        """Get model-specific configuration parameters."""
-        base_config = {
-            "temperature": self.temperature,
-            "max_tokens": self.max_tokens,
-            "top_p": self.top_p,
-            "top_k": self.top_k,
-        }
-
-        # Add custom model kwargs
-        base_config.update(self.model_kwargs)
-
-        return base_config
-
-    def get_aws_config(self) -> Dict[str, Any]:
-        """Get AWS configuration parameters."""
-        config = {
-            "region_name": self.aws_region,
-        }
-
-        if self.aws_access_key_id:
-            config["aws_access_key_id"] = self.aws_access_key_id or os.getenv("AWS_ACCESS_KEY_ID")
-            
-        if self.aws_secret_access_key:
-            config["aws_secret_access_key"] = self.aws_secret_access_key or os.getenv("AWS_SECRET_ACCESS_KEY")
-            
-        if self.aws_session_token:
-            config["aws_session_token"] = self.aws_session_token or os.getenv("AWS_SESSION_TOKEN")
-            
-        if self.aws_profile:
-            config["profile_name"] = self.aws_profile or os.getenv("AWS_PROFILE")
-
-        return config
-
-    def validate_model_format(self) -> bool:
-        """
-        Validate that the model identifier follows Bedrock naming convention.
-        
-        Returns:
-            True if valid, False otherwise
-        """
-        if not self.model:
-            return False
-            
-        # Check if model follows provider.model-name format
-        if "." not in self.model:
-            return False
-            
-        provider, model_name = self.model.split(".", 1)
-        
-        # Validate provider
-        valid_providers = [
-            "ai21", "amazon", "anthropic", "cohere", "meta", "mistral", 
-            "stability", "writer", "deepseek", "gpt-oss", "perplexity", 
-            "snowflake", "titan", "command", "j2", "llama"
-        ]
-        
-        if provider not in valid_providers:
-            return False
-            
-        # Validate model name is not empty
-        if not model_name:
-            return False
-            
-        return True
-
-    def get_supported_regions(self) -> List[str]:
-        """Get list of AWS regions that support Bedrock."""
-        return [
-            "us-east-1",
-            "us-west-2",
-            "us-east-2",
-            "eu-west-1",
-            "ap-southeast-1",
-            "ap-northeast-1",
-        ]
-
-    def get_model_capabilities(self) -> Dict[str, Any]:
-        """Get model capabilities based on provider."""
-        capabilities = {
-            "supports_tools": False,
-            "supports_vision": False,
-            "supports_streaming": False,
-            "supports_multimodal": False,
-        }
-        
-        if self.provider == "anthropic":
-            capabilities.update({
-                "supports_tools": True,
-                "supports_vision": True,
-                "supports_streaming": True,
-                "supports_multimodal": True,
-            })
-        elif self.provider == "amazon":
-            capabilities.update({
-                "supports_tools": True,
-                "supports_vision": True,
-                "supports_streaming": True,
-                "supports_multimodal": True,
-            })
-        elif self.provider == "cohere":
-            capabilities.update({
-                "supports_tools": True,
-                "supports_streaming": True,
-            })
-        elif self.provider == "meta":
-            capabilities.update({
-                "supports_vision": True,
-                "supports_streaming": True,
-            })
-        elif self.provider == "mistral":
-            capabilities.update({
-                "supports_vision": True,
-                "supports_streaming": True,
-            })
-            
-        return capabilities

neomem/neomem/configs/llms/azure.py

@@ -1,57 +0,0 @@
-from typing import Any, Dict, Optional
-
-from mem0.configs.base import AzureConfig
-from mem0.configs.llms.base import BaseLlmConfig
-
-
-class AzureOpenAIConfig(BaseLlmConfig):
-    """
-    Configuration class for Azure OpenAI-specific parameters.
-    Inherits from BaseLlmConfig and adds Azure OpenAI-specific settings.
-    """
-
-    def __init__(
-        self,
-        # Base parameters
-        model: Optional[str] = None,
-        temperature: float = 0.1,
-        api_key: Optional[str] = None,
-        max_tokens: int = 2000,
-        top_p: float = 0.1,
-        top_k: int = 1,
-        enable_vision: bool = False,
-        vision_details: Optional[str] = "auto",
-        http_client_proxies: Optional[dict] = None,
-        # Azure OpenAI-specific parameters
-        azure_kwargs: Optional[Dict[str, Any]] = None,
-    ):
-        """
-        Initialize Azure OpenAI configuration.
-
-        Args:
-            model: Azure OpenAI model to use, defaults to None
-            temperature: Controls randomness, defaults to 0.1
-            api_key: Azure OpenAI API key, defaults to None
-            max_tokens: Maximum tokens to generate, defaults to 2000
-            top_p: Nucleus sampling parameter, defaults to 0.1
-            top_k: Top-k sampling parameter, defaults to 1
-            enable_vision: Enable vision capabilities, defaults to False
-            vision_details: Vision detail level, defaults to "auto"
-            http_client_proxies: HTTP client proxy settings, defaults to None
-            azure_kwargs: Azure-specific configuration, defaults to None
-        """
-        # Initialize base parameters
-        super().__init__(
-            model=model,
-            temperature=temperature,
-            api_key=api_key,
-            max_tokens=max_tokens,
-            top_p=top_p,
-            top_k=top_k,
-            enable_vision=enable_vision,
-            vision_details=vision_details,
-            http_client_proxies=http_client_proxies,
-        )
-
-        # Azure OpenAI-specific parameters
-        self.azure_kwargs = AzureConfig(**(azure_kwargs or {}))

neomem/neomem/configs/llms/base.py

@@ -1,62 +0,0 @@
-from abc import ABC
-from typing import Dict, Optional, Union
-
-import httpx
-
-
-class BaseLlmConfig(ABC):
-    """
-    Base configuration for LLMs with only common parameters.
-    Provider-specific configurations should be handled by separate config classes.
-
-    This class contains only the parameters that are common across all LLM providers.
-    For provider-specific parameters, use the appropriate provider config class.
-    """
-
-    def __init__(
-        self,
-        model: Optional[Union[str, Dict]] = None,
-        temperature: float = 0.1,
-        api_key: Optional[str] = None,
-        max_tokens: int = 2000,
-        top_p: float = 0.1,
-        top_k: int = 1,
-        enable_vision: bool = False,
-        vision_details: Optional[str] = "auto",
-        http_client_proxies: Optional[Union[Dict, str]] = None,
-    ):
-        """
-        Initialize a base configuration class instance for the LLM.
-
-        Args:
-            model: The model identifier to use (e.g., "gpt-4o-mini", "claude-3-5-sonnet-20240620")
-                Defaults to None (will be set by provider-specific configs)
-            temperature: Controls the randomness of the model's output.
-                Higher values (closer to 1) make output more random, lower values make it more deterministic.
-                Range: 0.0 to 2.0. Defaults to 0.1
-            api_key: API key for the LLM provider. If None, will try to get from environment variables.
-                Defaults to None
-            max_tokens: Maximum number of tokens to generate in the response.
-                Range: 1 to 4096 (varies by model). Defaults to 2000
-            top_p: Nucleus sampling parameter. Controls diversity via nucleus sampling.
-                Higher values (closer to 1) make word selection more diverse.
-                Range: 0.0 to 1.0. Defaults to 0.1
-            top_k: Top-k sampling parameter. Limits the number of tokens considered for each step.
-                Higher values make word selection more diverse.
-                Range: 1 to 40. Defaults to 1
-            enable_vision: Whether to enable vision capabilities for the model.
-                Only applicable to vision-enabled models. Defaults to False
-            vision_details: Level of detail for vision processing.
-                Options: "low", "high", "auto". Defaults to "auto"
-            http_client_proxies: Proxy settings for HTTP client.
-                Can be a dict or string. Defaults to None
-        """
-        self.model = model
-        self.temperature = temperature
-        self.api_key = api_key
-        self.max_tokens = max_tokens
-        self.top_p = top_p
-        self.top_k = top_k
-        self.enable_vision = enable_vision
-        self.vision_details = vision_details
-        self.http_client = httpx.Client(proxies=http_client_proxies) if http_client_proxies else None

neomem/neomem/configs/llms/deepseek.py

@@ -1,56 +0,0 @@
-from typing import Optional
-
-from mem0.configs.llms.base import BaseLlmConfig
-
-
-class DeepSeekConfig(BaseLlmConfig):
-    """
-    Configuration class for DeepSeek-specific parameters.
-    Inherits from BaseLlmConfig and adds DeepSeek-specific settings.
-    """
-
-    def __init__(
-        self,
-        # Base parameters
-        model: Optional[str] = None,
-        temperature: float = 0.1,
-        api_key: Optional[str] = None,
-        max_tokens: int = 2000,
-        top_p: float = 0.1,
-        top_k: int = 1,
-        enable_vision: bool = False,
-        vision_details: Optional[str] = "auto",
-        http_client_proxies: Optional[dict] = None,
-        # DeepSeek-specific parameters
-        deepseek_base_url: Optional[str] = None,
-    ):
-        """
-        Initialize DeepSeek configuration.
-
-        Args:
-            model: DeepSeek model to use, defaults to None
-            temperature: Controls randomness, defaults to 0.1
-            api_key: DeepSeek API key, defaults to None
-            max_tokens: Maximum tokens to generate, defaults to 2000
-            top_p: Nucleus sampling parameter, defaults to 0.1
-            top_k: Top-k sampling parameter, defaults to 1
-            enable_vision: Enable vision capabilities, defaults to False
-            vision_details: Vision detail level, defaults to "auto"
-            http_client_proxies: HTTP client proxy settings, defaults to None
-            deepseek_base_url: DeepSeek API base URL, defaults to None
-        """
-        # Initialize base parameters
-        super().__init__(
-            model=model,
-            temperature=temperature,
-            api_key=api_key,
-            max_tokens=max_tokens,
-            top_p=top_p,
-            top_k=top_k,
-            enable_vision=enable_vision,
-            vision_details=vision_details,
-            http_client_proxies=http_client_proxies,
-        )
-
-        # DeepSeek-specific parameters
-        self.deepseek_base_url = deepseek_base_url

neomem/neomem/configs/llms/lmstudio.py

@@ -1,59 +0,0 @@
-from typing import Any, Dict, Optional
-
-from mem0.configs.llms.base import BaseLlmConfig
-
-
-class LMStudioConfig(BaseLlmConfig):
-    """
-    Configuration class for LM Studio-specific parameters.
-    Inherits from BaseLlmConfig and adds LM Studio-specific settings.
-    """
-
-    def __init__(
-        self,
-        # Base parameters
-        model: Optional[str] = None,
-        temperature: float = 0.1,
-        api_key: Optional[str] = None,
-        max_tokens: int = 2000,
-        top_p: float = 0.1,
-        top_k: int = 1,
-        enable_vision: bool = False,
-        vision_details: Optional[str] = "auto",
-        http_client_proxies: Optional[dict] = None,
-        # LM Studio-specific parameters
-        lmstudio_base_url: Optional[str] = None,
-        lmstudio_response_format: Optional[Dict[str, Any]] = None,
-    ):
-        """
-        Initialize LM Studio configuration.
-
-        Args:
-            model: LM Studio model to use, defaults to None
-            temperature: Controls randomness, defaults to 0.1
-            api_key: LM Studio API key, defaults to None
-            max_tokens: Maximum tokens to generate, defaults to 2000
-            top_p: Nucleus sampling parameter, defaults to 0.1
-            top_k: Top-k sampling parameter, defaults to 1
-            enable_vision: Enable vision capabilities, defaults to False
-            vision_details: Vision detail level, defaults to "auto"
-            http_client_proxies: HTTP client proxy settings, defaults to None
-            lmstudio_base_url: LM Studio base URL, defaults to None
-            lmstudio_response_format: LM Studio response format, defaults to None
-        """
-        # Initialize base parameters
-        super().__init__(
-            model=model,
-            temperature=temperature,
-            api_key=api_key,
-            max_tokens=max_tokens,
-            top_p=top_p,
-            top_k=top_k,
-            enable_vision=enable_vision,
-            vision_details=vision_details,
-            http_client_proxies=http_client_proxies,
-        )
-
-        # LM Studio-specific parameters
-        self.lmstudio_base_url = lmstudio_base_url or "http://localhost:1234/v1"
-        self.lmstudio_response_format = lmstudio_response_format

neomem/neomem/configs/llms/ollama.py

@@ -1,56 +0,0 @@
-from typing import Optional
-
-from neomem.configs.llms.base import BaseLlmConfig
-
-
-class OllamaConfig(BaseLlmConfig):
-    """
-    Configuration class for Ollama-specific parameters.
-    Inherits from BaseLlmConfig and adds Ollama-specific settings.
-    """
-
-    def __init__(
-        self,
-        # Base parameters
-        model: Optional[str] = None,
-        temperature: float = 0.1,
-        api_key: Optional[str] = None,
-        max_tokens: int = 2000,
-        top_p: float = 0.1,
-        top_k: int = 1,
-        enable_vision: bool = False,
-        vision_details: Optional[str] = "auto",
-        http_client_proxies: Optional[dict] = None,
-        # Ollama-specific parameters
-        ollama_base_url: Optional[str] = None,
-    ):
-        """
-        Initialize Ollama configuration.
-
-        Args:
-            model: Ollama model to use, defaults to None
-            temperature: Controls randomness, defaults to 0.1
-            api_key: Ollama API key, defaults to None
-            max_tokens: Maximum tokens to generate, defaults to 2000
-            top_p: Nucleus sampling parameter, defaults to 0.1
-            top_k: Top-k sampling parameter, defaults to 1
-            enable_vision: Enable vision capabilities, defaults to False
-            vision_details: Vision detail level, defaults to "auto"
-            http_client_proxies: HTTP client proxy settings, defaults to None
-            ollama_base_url: Ollama base URL, defaults to None
-        """
-        # Initialize base parameters
-        super().__init__(
-            model=model,
-            temperature=temperature,
-            api_key=api_key,
-            max_tokens=max_tokens,
-            top_p=top_p,
-            top_k=top_k,
-            enable_vision=enable_vision,
-            vision_details=vision_details,
-            http_client_proxies=http_client_proxies,
-        )
-
-        # Ollama-specific parameters
-        self.ollama_base_url = ollama_base_url

neomem/neomem/configs/llms/openai.py

@@ -1,79 +0,0 @@
-from typing import Any, Callable, List, Optional
-
-from neomem.configs.llms.base import BaseLlmConfig
-
-
-class OpenAIConfig(BaseLlmConfig):
-    """
-    Configuration class for OpenAI and OpenRouter-specific parameters.
-    Inherits from BaseLlmConfig and adds OpenAI-specific settings.
-    """
-
-    def __init__(
-        self,
-        # Base parameters
-        model: Optional[str] = None,
-        temperature: float = 0.1,
-        api_key: Optional[str] = None,
-        max_tokens: int = 2000,
-        top_p: float = 0.1,
-        top_k: int = 1,
-        enable_vision: bool = False,
-        vision_details: Optional[str] = "auto",
-        http_client_proxies: Optional[dict] = None,
-        # OpenAI-specific parameters
-        openai_base_url: Optional[str] = None,
-        models: Optional[List[str]] = None,
-        route: Optional[str] = "fallback",
-        openrouter_base_url: Optional[str] = None,
-        site_url: Optional[str] = None,
-        app_name: Optional[str] = None,
-        store: bool = False,
-        # Response monitoring callback
-        response_callback: Optional[Callable[[Any, dict, dict], None]] = None,
-    ):
-        """
-        Initialize OpenAI configuration.
-
-        Args:
-            model: OpenAI model to use, defaults to None
-            temperature: Controls randomness, defaults to 0.1
-            api_key: OpenAI API key, defaults to None
-            max_tokens: Maximum tokens to generate, defaults to 2000
-            top_p: Nucleus sampling parameter, defaults to 0.1
-            top_k: Top-k sampling parameter, defaults to 1
-            enable_vision: Enable vision capabilities, defaults to False
-            vision_details: Vision detail level, defaults to "auto"
-            http_client_proxies: HTTP client proxy settings, defaults to None
-            openai_base_url: OpenAI API base URL, defaults to None
-            models: List of models for OpenRouter, defaults to None
-            route: OpenRouter route strategy, defaults to "fallback"
-            openrouter_base_url: OpenRouter base URL, defaults to None
-            site_url: Site URL for OpenRouter, defaults to None
-            app_name: Application name for OpenRouter, defaults to None
-            response_callback: Optional callback for monitoring LLM responses.
-        """
-        # Initialize base parameters
-        super().__init__(
-            model=model,
-            temperature=temperature,
-            api_key=api_key,
-            max_tokens=max_tokens,
-            top_p=top_p,
-            top_k=top_k,
-            enable_vision=enable_vision,
-            vision_details=vision_details,
-            http_client_proxies=http_client_proxies,
-        )
-
-        # OpenAI-specific parameters
-        self.openai_base_url = openai_base_url
-        self.models = models
-        self.route = route
-        self.openrouter_base_url = openrouter_base_url
-        self.site_url = site_url
-        self.app_name = app_name
-        self.store = store
-
-        # Response monitoring
-        self.response_callback = response_callback