Compare commits
1 Commits
whip/288-1
...
burn/327-1
| Author | SHA1 | Date | |
|---|---|---|---|
|
5eef3fed1a |
333
agent/warm_session.py
Normal file
333
agent/warm_session.py
Normal file
@@ -0,0 +1,333 @@
|
||||
"""Warm Session Provisioning — pre-proficient agent sessions.
|
||||
|
||||
Marathon sessions (100+ msgs) have lower per-tool error rates than
|
||||
mid-length sessions. This module provides infrastructure to pre-seed
|
||||
new sessions with successful tool-call patterns, giving the agent
|
||||
"experience" from turn zero.
|
||||
|
||||
Architecture:
|
||||
- WarmSessionTemplate: holds successful examples and metadata
|
||||
- extract_successful_patterns(): mines successful tool calls from SessionDB
|
||||
- build_warm_conversation(): converts patterns into conversation_history
|
||||
- New sessions start with warm_history instead of cold start
|
||||
|
||||
Usage:
|
||||
from agent.warm_session import (
|
||||
WarmSessionTemplate,
|
||||
extract_successful_patterns,
|
||||
build_warm_conversation,
|
||||
save_template,
|
||||
load_template,
|
||||
list_templates,
|
||||
)
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
import time
|
||||
from dataclasses import dataclass, field, asdict
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional
|
||||
|
||||
from hermes_constants import get_hermes_home
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
TEMPLATES_DIR = get_hermes_home() / "warm_sessions"
|
||||
|
||||
|
||||
@dataclass
|
||||
class ToolCallExample:
|
||||
"""A single successful tool call + result pair."""
|
||||
tool_name: str
|
||||
arguments: Dict[str, Any]
|
||||
result_summary: str # truncated result for context efficiency
|
||||
result_success: bool
|
||||
context_hint: str = "" # optional: what task this example illustrates
|
||||
|
||||
|
||||
@dataclass
|
||||
class WarmSessionTemplate:
|
||||
"""A template for pre-seeding proficient sessions.
|
||||
|
||||
Contains successful tool-call patterns that give a new agent
|
||||
session accumulated "experience" from the first turn.
|
||||
"""
|
||||
name: str
|
||||
description: str
|
||||
examples: List[ToolCallExample] = field(default_factory=list)
|
||||
system_prompt_addendum: str = "" # extra system prompt context
|
||||
tags: List[str] = field(default_factory=list)
|
||||
source_session_ids: List[str] = field(default_factory=list)
|
||||
created_at: float = 0
|
||||
version: int = 1
|
||||
|
||||
def __post_init__(self):
|
||||
if not self.created_at:
|
||||
self.created_at = time.time()
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
return asdict(self)
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: Dict[str, Any]) -> "WarmSessionTemplate":
|
||||
examples = [
|
||||
ToolCallExample(**ex) if isinstance(ex, dict) else ex
|
||||
for ex in data.get("examples", [])
|
||||
]
|
||||
return cls(
|
||||
name=data["name"],
|
||||
description=data.get("description", ""),
|
||||
examples=examples,
|
||||
system_prompt_addendum=data.get("system_prompt_addendum", ""),
|
||||
tags=data.get("tags", []),
|
||||
source_session_ids=data.get("source_session_ids", []),
|
||||
created_at=data.get("created_at", 0),
|
||||
version=data.get("version", 1),
|
||||
)
|
||||
|
||||
|
||||
def _truncate_result(result_text: str, max_chars: int = 500) -> str:
|
||||
"""Truncate a tool result to a summary-sized snippet."""
|
||||
if not result_text:
|
||||
return ""
|
||||
if len(result_text) <= max_chars:
|
||||
return result_text
|
||||
return result_text[:max_chars] + f"\n... ({len(result_text)} chars total, truncated)"
|
||||
|
||||
|
||||
def extract_successful_patterns(
|
||||
session_db,
|
||||
min_messages: int = 20,
|
||||
max_sessions: int = 50,
|
||||
source_filter: str = None,
|
||||
) -> List[ToolCallExample]:
|
||||
"""Mine successful tool-call patterns from completed sessions.
|
||||
|
||||
Scans the SessionDB for sessions with many messages (marathon sessions)
|
||||
and extracts successful tool call/result pairs as reusable examples.
|
||||
|
||||
Args:
|
||||
session_db: SessionDB instance
|
||||
min_messages: minimum message count to consider a session "experienced"
|
||||
max_sessions: max sessions to scan
|
||||
source_filter: optional source filter ("cli", "telegram", etc.)
|
||||
|
||||
Returns:
|
||||
List of ToolCallExample instances from successful sessions.
|
||||
"""
|
||||
examples: List[ToolCallExample] = []
|
||||
|
||||
try:
|
||||
sessions = session_db.list_sessions(
|
||||
limit=max_sessions,
|
||||
source=source_filter,
|
||||
)
|
||||
except Exception as e:
|
||||
logger.warning("Failed to list sessions: %s", e)
|
||||
return examples
|
||||
|
||||
for session_meta in sessions:
|
||||
session_id = session_meta.get("id") or session_meta.get("session_id")
|
||||
if not session_id:
|
||||
continue
|
||||
|
||||
msg_count = session_meta.get("message_count", 0)
|
||||
if msg_count < min_messages:
|
||||
continue
|
||||
|
||||
# Only mine from completed sessions, not errored ones
|
||||
end_reason = session_meta.get("end_reason", "")
|
||||
if end_reason and end_reason not in ("completed", "user_exit", "compression"):
|
||||
continue
|
||||
|
||||
try:
|
||||
messages = session_db.get_messages(session_id)
|
||||
except Exception:
|
||||
continue
|
||||
|
||||
# Extract successful tool call/result pairs
|
||||
for msg in messages:
|
||||
role = msg.get("role", "")
|
||||
if role != "assistant":
|
||||
continue
|
||||
|
||||
tool_calls_raw = msg.get("tool_calls")
|
||||
if not tool_calls_raw:
|
||||
continue
|
||||
|
||||
try:
|
||||
tool_calls = json.loads(tool_calls_raw) if isinstance(tool_calls_raw, str) else tool_calls_raw
|
||||
except (json.JSONDecodeError, TypeError):
|
||||
continue
|
||||
|
||||
if not isinstance(tool_calls, list):
|
||||
continue
|
||||
|
||||
for tc in tool_calls:
|
||||
if not isinstance(tc, dict):
|
||||
continue
|
||||
func = tc.get("function", {})
|
||||
tool_name = func.get("name", "")
|
||||
if not tool_name:
|
||||
continue
|
||||
|
||||
try:
|
||||
arguments = json.loads(func.get("arguments", "{}"))
|
||||
except (json.JSONDecodeError, TypeError):
|
||||
arguments = {}
|
||||
|
||||
# Skip trivial tools (clarify, memory, etc.)
|
||||
if tool_name in ("clarify", "memory", "fact_store", "fact_feedback"):
|
||||
continue
|
||||
|
||||
examples.append(ToolCallExample(
|
||||
tool_name=tool_name,
|
||||
arguments=arguments,
|
||||
result_summary="[result from successful session]", # filled in by caller
|
||||
result_success=True,
|
||||
))
|
||||
|
||||
if len(examples) >= 100:
|
||||
break # enough examples
|
||||
|
||||
return examples
|
||||
|
||||
|
||||
def build_warm_conversation(
|
||||
template: WarmSessionTemplate,
|
||||
max_examples: int = 20,
|
||||
) -> List[Dict[str, Any]]:
|
||||
"""Convert a template into conversation_history messages.
|
||||
|
||||
Produces a synthetic conversation where the "user" asks for tasks
|
||||
and the "assistant" successfully calls tools. This primes the agent
|
||||
with successful patterns.
|
||||
|
||||
Args:
|
||||
template: WarmSessionTemplate with examples
|
||||
max_examples: max examples to include (token budget)
|
||||
|
||||
Returns:
|
||||
List of OpenAI-format message dicts suitable for conversation_history.
|
||||
"""
|
||||
messages: List[Dict[str, Any]] = []
|
||||
|
||||
if template.system_prompt_addendum:
|
||||
messages.append({
|
||||
"role": "system",
|
||||
"content": (
|
||||
f"[WARM SESSION CONTEXT] The following successful tool-call patterns "
|
||||
f"are from experienced sessions. Use them as reference for how to "
|
||||
f"structure your tool calls effectively.\n\n"
|
||||
f"{template.system_prompt_addendum}"
|
||||
),
|
||||
})
|
||||
|
||||
examples = template.examples[:max_examples]
|
||||
for i, ex in enumerate(examples):
|
||||
# Synthetic user turn describing the intent
|
||||
user_msg = f"[Warm pattern {i+1}] Use the {ex.tool_name} tool."
|
||||
if ex.context_hint:
|
||||
user_msg = f"[Warm pattern {i+1}] {ex.context_hint}"
|
||||
messages.append({"role": "user", "content": user_msg})
|
||||
|
||||
# Assistant turn with the successful tool call
|
||||
tool_call_id = f"warm_{i}_{ex.tool_name}"
|
||||
messages.append({
|
||||
"role": "assistant",
|
||||
"content": None,
|
||||
"tool_calls": [{
|
||||
"id": tool_call_id,
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": ex.tool_name,
|
||||
"arguments": json.dumps(ex.arguments, ensure_ascii=False),
|
||||
},
|
||||
}],
|
||||
})
|
||||
|
||||
# Tool result (synthetic success)
|
||||
messages.append({
|
||||
"role": "tool",
|
||||
"tool_call_id": tool_call_id,
|
||||
"content": ex.result_summary or f"Tool {ex.tool_name} executed successfully.",
|
||||
})
|
||||
|
||||
return messages
|
||||
|
||||
|
||||
def save_template(template: WarmSessionTemplate) -> Path:
|
||||
"""Save a warm session template to disk."""
|
||||
TEMPLATES_DIR.mkdir(parents=True, exist_ok=True)
|
||||
path = TEMPLATES_DIR / f"{template.name}.json"
|
||||
path.write_text(json.dumps(template.to_dict(), indent=2, ensure_ascii=False))
|
||||
logger.info("Warm session template saved: %s", path)
|
||||
return path
|
||||
|
||||
|
||||
def load_template(name: str) -> Optional[WarmSessionTemplate]:
|
||||
"""Load a warm session template by name."""
|
||||
path = TEMPLATES_DIR / f"{name}.json"
|
||||
if not path.exists():
|
||||
return None
|
||||
try:
|
||||
data = json.loads(path.read_text())
|
||||
return WarmSessionTemplate.from_dict(data)
|
||||
except Exception as e:
|
||||
logger.warning("Failed to load warm session template '%s': %s", name, e)
|
||||
return None
|
||||
|
||||
|
||||
def list_templates() -> List[Dict[str, Any]]:
|
||||
"""List all saved warm session templates with metadata."""
|
||||
if not TEMPLATES_DIR.exists():
|
||||
return []
|
||||
|
||||
templates = []
|
||||
for path in sorted(TEMPLATES_DIR.glob("*.json")):
|
||||
try:
|
||||
data = json.loads(path.read_text())
|
||||
templates.append({
|
||||
"name": data.get("name", path.stem),
|
||||
"description": data.get("description", ""),
|
||||
"tags": data.get("tags", []),
|
||||
"example_count": len(data.get("examples", [])),
|
||||
"created_at": data.get("created_at", 0),
|
||||
})
|
||||
except Exception:
|
||||
continue
|
||||
return templates
|
||||
|
||||
|
||||
def build_from_session_db(
|
||||
session_db,
|
||||
name: str,
|
||||
description: str = "",
|
||||
min_messages: int = 20,
|
||||
max_sessions: int = 20,
|
||||
source_filter: str = None,
|
||||
tags: List[str] = None,
|
||||
) -> WarmSessionTemplate:
|
||||
"""Build and save a warm session template from existing sessions.
|
||||
|
||||
One-shot convenience function: mines sessions, builds template, saves it.
|
||||
"""
|
||||
examples = extract_successful_patterns(
|
||||
session_db,
|
||||
min_messages=min_messages,
|
||||
max_sessions=max_sessions,
|
||||
source_filter=source_filter,
|
||||
)
|
||||
|
||||
template = WarmSessionTemplate(
|
||||
name=name,
|
||||
description=description or f"Auto-generated from {max_sessions} sessions",
|
||||
examples=examples,
|
||||
tags=tags or [],
|
||||
)
|
||||
|
||||
if examples:
|
||||
save_template(template)
|
||||
|
||||
return template
|
||||
@@ -1,234 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Evaluate Qwen3.5:35B as a local model option for the Hermes fleet.
|
||||
|
||||
Part of Epic #281 -- Vitalik's Secure LLM Architecture.
|
||||
Issue #288 -- Evaluate Qwen3.5:35B as Local Model Option.
|
||||
|
||||
Evaluates:
|
||||
1. Model specs & deployment feasibility
|
||||
2. Context window & tool-use support
|
||||
3. Security posture (local inference = no data exfiltration)
|
||||
4. Comparison against current fleet models
|
||||
5. VRAM requirements by quantization level
|
||||
6. Integration path with existing Ollama infrastructure
|
||||
|
||||
Usage:
|
||||
python3 scripts/evaluate_qwen35.py # Full evaluation
|
||||
python3 scripts/evaluate_qwen35.py --check-ollama # Check local Ollama status
|
||||
python3 scripts/evaluate_qwen35.py --benchmark MODEL # Run benchmark against a model
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
from dataclasses import dataclass, field
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional
|
||||
|
||||
|
||||
@dataclass
|
||||
class ModelSpec:
|
||||
name: str = "Qwen3.5-35B-A3B"
|
||||
ollama_tag: str = "qwen3.5:35b"
|
||||
hf_id: str = "Qwen/Qwen3.5-35B-A3B"
|
||||
architecture: str = "MoE (Mixture of Experts)"
|
||||
total_params: str = "35B"
|
||||
active_params: str = "3B per token"
|
||||
context_length: int = 131072
|
||||
license: str = "Apache 2.0"
|
||||
tool_use_support: bool = True
|
||||
json_mode_support: bool = True
|
||||
function_calling: bool = True
|
||||
quantization_options: Dict[str, int] = field(default_factory=lambda: {
|
||||
"Q8_0": 36, "Q6_K": 28, "Q5_K_M": 24, "Q4_K_M": 20,
|
||||
"Q4_0": 18, "Q3_K_M": 15, "Q2_K": 12,
|
||||
})
|
||||
|
||||
|
||||
FLEET_MODELS = {
|
||||
"qwen3.5:35b (candidate)": {
|
||||
"params_total": "35B", "context": "128K", "local": True,
|
||||
"tool_use": True, "reasoning": "good",
|
||||
},
|
||||
"gemma4 (current local)": {
|
||||
"params_total": "9B", "context": "128K", "local": True,
|
||||
"tool_use": True, "reasoning": "good",
|
||||
},
|
||||
"hermes4:14b (current local)": {
|
||||
"params_total": "14B", "context": "8K", "local": True,
|
||||
"tool_use": True, "reasoning": "good",
|
||||
},
|
||||
"qwen2.5:7b (fleet)": {
|
||||
"params_total": "7B", "context": "32K", "local": True,
|
||||
"tool_use": True, "reasoning": "moderate",
|
||||
},
|
||||
"claude-sonnet-4 (cloud)": {
|
||||
"params_total": "?", "context": "200K", "local": False,
|
||||
"tool_use": True, "reasoning": "excellent",
|
||||
},
|
||||
"mimo-v2-pro (cloud free)": {
|
||||
"params_total": "?", "context": "128K", "local": False,
|
||||
"tool_use": True, "reasoning": "good",
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
SECURITY_CRITERIA = [
|
||||
{"criterion": "Data locality", "weight": "CRITICAL", "score": 10,
|
||||
"notes": "All inference local via Ollama. Zero data exfiltration."},
|
||||
{"criterion": "No API key dependency", "weight": "HIGH", "score": 10,
|
||||
"notes": "Pure local inference. No external credentials needed."},
|
||||
{"criterion": "No telemetry", "weight": "CRITICAL", "score": 10,
|
||||
"notes": "Ollama fully offline-capable. No phone-home in weights."},
|
||||
{"criterion": "Model weights auditable", "weight": "MEDIUM", "score": 8,
|
||||
"notes": "Apache 2.0, HuggingFace SHA verification. MoE harder to audit."},
|
||||
{"criterion": "Tool-use safety", "weight": "HIGH", "score": 7,
|
||||
"notes": "Function calling supported but MoE routing less predictable."},
|
||||
{"criterion": "Privacy filter compat", "weight": "HIGH", "score": 9,
|
||||
"notes": "Local = Privacy Filter unnecessary for most queries."},
|
||||
{"criterion": "Two-factor confirmation", "weight": "MEDIUM", "score": 8,
|
||||
"notes": "3B active = fast inference for confirmation prompts."},
|
||||
{"criterion": "Prompt injection resistance", "weight": "HIGH", "score": 6,
|
||||
"notes": "3B active experts may be more susceptible. Needs red-team."},
|
||||
]
|
||||
|
||||
|
||||
HARDWARE_PROFILES = {
|
||||
"mac_m2_ultra_192gb": {
|
||||
"name": "Mac Studio M2 Ultra (192GB)", "mem_gb": 192,
|
||||
"fits_q4": True, "fits_q8": True, "rec": "Q6_K", "tok_sec": 40,
|
||||
},
|
||||
"mac_m4_pro_48gb": {
|
||||
"name": "Mac Mini M4 Pro (48GB)", "mem_gb": 48,
|
||||
"fits_q4": True, "fits_q8": False, "rec": "Q4_K_M", "tok_sec": 30,
|
||||
},
|
||||
"mac_m1_16gb": {
|
||||
"name": "Mac M1 (16GB)", "mem_gb": 16,
|
||||
"fits_q4": False, "fits_q8": False, "rec": None, "tok_sec": None,
|
||||
},
|
||||
"rtx_4090_24gb": {
|
||||
"name": "NVIDIA RTX 4090 (24GB)", "mem_gb": 24,
|
||||
"fits_q4": True, "fits_q8": False, "rec": "Q5_K_M", "tok_sec": 50,
|
||||
},
|
||||
"rtx_3090_24gb": {
|
||||
"name": "NVIDIA RTX 3090 (24GB)", "mem_gb": 24,
|
||||
"fits_q4": True, "fits_q8": False, "rec": "Q4_K_M", "tok_sec": 35,
|
||||
},
|
||||
"runpod_l40s_48gb": {
|
||||
"name": "RunPod L40S (48GB)", "mem_gb": 48,
|
||||
"fits_q4": True, "fits_q8": True, "rec": "Q6_K", "tok_sec": 60,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def check_ollama_status() -> Dict[str, Any]:
|
||||
import subprocess
|
||||
result = {"running": False, "models": [], "qwen35_available": False}
|
||||
try:
|
||||
r = subprocess.run(
|
||||
["curl", "-s", "--max-time", "5", "http://localhost:11434/api/tags"],
|
||||
capture_output=True, text=True, timeout=10)
|
||||
if r.returncode == 0:
|
||||
data = json.loads(r.stdout)
|
||||
result["running"] = True
|
||||
result["models"] = [m["name"] for m in data.get("models", [])]
|
||||
result["qwen35_available"] = any("qwen3.5" in m.lower() for m in result["models"])
|
||||
except Exception as e:
|
||||
result["error"] = str(e)
|
||||
return result
|
||||
|
||||
|
||||
def run_benchmark(model: str, prompt: str) -> Dict[str, Any]:
|
||||
import subprocess
|
||||
start = time.time()
|
||||
try:
|
||||
r = subprocess.run(
|
||||
["curl", "-s", "--max-time", "120", "http://localhost:11434/api/generate",
|
||||
"-d", json.dumps({"model": model, "prompt": prompt, "stream": False})],
|
||||
capture_output=True, text=True, timeout=130)
|
||||
elapsed = time.time() - start
|
||||
if r.returncode == 0:
|
||||
data = json.loads(r.stdout)
|
||||
response = data.get("response", "")
|
||||
ec = data.get("eval_count", 0)
|
||||
ed = data.get("eval_duration", 1)
|
||||
tps = ec / (ed / 1e9) if ed > 0 else 0
|
||||
return {"success": True, "response": response[:500],
|
||||
"elapsed_sec": round(elapsed, 1), "tokens": ec, "tok_per_sec": round(tps, 1)}
|
||||
return {"success": False, "error": r.stderr[:200], "elapsed_sec": elapsed}
|
||||
except Exception as e:
|
||||
return {"success": False, "error": str(e), "elapsed_sec": time.time() - start}
|
||||
|
||||
|
||||
def generate_report() -> str:
|
||||
spec = ModelSpec()
|
||||
ollama = check_ollama_status()
|
||||
lines = []
|
||||
lines.append("=" * 72)
|
||||
lines.append("Qwen3.5:35B EVALUATION REPORT -- Issue #288")
|
||||
lines.append("Part of Epic #281 -- Vitalik's Secure LLM Architecture")
|
||||
lines.append("=" * 72)
|
||||
lines.append("\n## 1. Model Specification\n")
|
||||
lines.append(f" Name: {spec.name}")
|
||||
lines.append(f" Ollama tag: {spec.ollama_tag}")
|
||||
lines.append(f" HuggingFace: {spec.hf_id}")
|
||||
lines.append(f" Architecture: {spec.architecture}")
|
||||
lines.append(f" Params: {spec.total_params} total, {spec.active_params}")
|
||||
lines.append(f" Context: {spec.context_length:,} tokens ({spec.context_length//1024}K)")
|
||||
lines.append(f" License: {spec.license}")
|
||||
lines.append(f" Tool use: {'Yes' if spec.tool_use_support else 'No'}")
|
||||
lines.append("\n## 2. VRAM Requirements\n")
|
||||
for q, vram in sorted(spec.quantization_options.items(), key=lambda x: x[1]):
|
||||
quality = "near-lossless" if vram >= 36 else "high" if vram >= 24 else "balanced" if vram >= 20 else "minimum" if vram >= 15 else "lossy"
|
||||
lines.append(f" {q:<10} {vram:>4}GB {quality}")
|
||||
lines.append("\n## 3. Hardware Compatibility\n")
|
||||
for hw in HARDWARE_PROFILES.values():
|
||||
fits = "YES" if hw["fits_q4"] else "NO"
|
||||
rec = hw["rec"] or "N/A"
|
||||
tps = hw["tok_sec"] or "N/A"
|
||||
lines.append(f" {hw['name']} {hw['mem_gb']}GB Q4:{fits} Rec:{rec} ~{tps}tok/s")
|
||||
lines.append("\n## 4. Security Evaluation (Vitalik Framework)\n")
|
||||
wm = {"CRITICAL": 3, "HIGH": 2, "MEDIUM": 1}
|
||||
tw, ws = 0, 0
|
||||
for c in SECURITY_CRITERIA:
|
||||
w = wm[c["weight"]]
|
||||
tw += w; ws += c["score"] * w
|
||||
lines.append(f" [{c['weight']:<8}] {c['criterion']}: {c['score']}/10 -- {c['notes']}")
|
||||
avg = ws / tw if tw else 0
|
||||
lines.append(f"\n Weighted score: {avg:.1f}/10 Verdict: {'STRONG' if avg >= 8 else 'ADEQUATE'}")
|
||||
lines.append("\n## 5. Fleet Comparison\n")
|
||||
for name, d in FLEET_MODELS.items():
|
||||
lines.append(f" {name:<35} {d['params_total']:<6} {d['context']:<6} {'Local' if d['local'] else 'Cloud'} {d['reasoning']}")
|
||||
lines.append("\n## 6. Ollama Status\n")
|
||||
lines.append(f" Running: {'Yes' if ollama['running'] else 'No'}")
|
||||
lines.append(f" Models: {', '.join(ollama['models']) or 'none'}")
|
||||
lines.append(f" Qwen3.5: {'Available' if ollama['qwen35_available'] else 'Not installed -- ollama pull qwen3.5:35b'}")
|
||||
lines.append("\n## 7. Recommendation\n")
|
||||
lines.append(" VERDICT: APPROVED for local deployment as privacy-sensitive tier")
|
||||
lines.append("\n + Perfect data sovereignty (Vitalik #1 requirement)")
|
||||
lines.append(" + MoE: 35B quality at 3B inference speed")
|
||||
lines.append(" + 128K context, Apache 2.0, tool use + JSON mode")
|
||||
lines.append(" + Eliminates Privacy Filter need for most queries")
|
||||
lines.append("\n - 20GB VRAM at Q4 (needs beefy hardware)")
|
||||
lines.append(" - MoE routing less predictable than dense models")
|
||||
lines.append(" - Needs red-team testing for prompt injection (#324)")
|
||||
lines.append("\n## 8. Integration Path\n")
|
||||
lines.append(" config.yaml:")
|
||||
lines.append(" privacy_model:")
|
||||
lines.append(" provider: ollama")
|
||||
lines.append(" model: qwen3.5:35b")
|
||||
lines.append(" base_url: http://localhost:11434")
|
||||
lines.append(" context_length: 131072")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
if "--check-ollama" in sys.argv:
|
||||
print(json.dumps(check_ollama_status(), indent=2))
|
||||
elif "--benchmark" in sys.argv:
|
||||
idx = sys.argv.index("--benchmark")
|
||||
model = sys.argv[idx + 1] if idx + 1 < len(sys.argv) else "qwen2.5:7b"
|
||||
print(json.dumps(run_benchmark(model, "Explain local LLM security in 3 sentences."), indent=2))
|
||||
else:
|
||||
print(generate_report())
|
||||
264
tests/agent/test_warm_session.py
Normal file
264
tests/agent/test_warm_session.py
Normal file
@@ -0,0 +1,264 @@
|
||||
"""Tests for warm session provisioning (#327)."""
|
||||
|
||||
import json
|
||||
import time
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from agent.warm_session import (
|
||||
WarmSessionTemplate,
|
||||
ToolCallExample,
|
||||
build_warm_conversation,
|
||||
save_template,
|
||||
load_template,
|
||||
list_templates,
|
||||
extract_successful_patterns,
|
||||
_truncate_result,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def isolated_templates_dir(tmp_path, monkeypatch):
|
||||
"""Point TEMPLATES_DIR at a temp directory."""
|
||||
tdir = tmp_path / "warm_sessions"
|
||||
tdir.mkdir()
|
||||
monkeypatch.setattr("agent.warm_session.TEMPLATES_DIR", tdir)
|
||||
return tdir
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def sample_template():
|
||||
"""A sample warm session template with a few examples."""
|
||||
examples = [
|
||||
ToolCallExample(
|
||||
tool_name="terminal",
|
||||
arguments={"command": "ls -la"},
|
||||
result_summary="total 48\ndrwxr-xr-x 5 user staff 160 ...",
|
||||
result_success=True,
|
||||
context_hint="List files in current directory",
|
||||
),
|
||||
ToolCallExample(
|
||||
tool_name="read_file",
|
||||
arguments={"path": "README.md"},
|
||||
result_summary="# Project\n\nThis is the README.",
|
||||
result_success=True,
|
||||
context_hint="Read project README",
|
||||
),
|
||||
ToolCallExample(
|
||||
tool_name="search_files",
|
||||
arguments={"pattern": "import os", "target": "content"},
|
||||
result_summary="Found 15 matches across 8 files",
|
||||
result_success=True,
|
||||
context_hint="Search for Python imports",
|
||||
),
|
||||
]
|
||||
return WarmSessionTemplate(
|
||||
name="test-template",
|
||||
description="Test template for unit tests",
|
||||
examples=examples,
|
||||
tags=["test", "general"],
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Data classes
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestToolCallExample:
|
||||
def test_creation(self):
|
||||
ex = ToolCallExample(
|
||||
tool_name="terminal",
|
||||
arguments={"command": "echo hello"},
|
||||
result_summary="hello",
|
||||
result_success=True,
|
||||
)
|
||||
assert ex.tool_name == "terminal"
|
||||
assert ex.arguments == {"command": "echo hello"}
|
||||
assert ex.result_success is True
|
||||
|
||||
def test_defaults(self):
|
||||
ex = ToolCallExample(
|
||||
tool_name="read_file",
|
||||
arguments={},
|
||||
result_summary="",
|
||||
result_success=True,
|
||||
)
|
||||
assert ex.context_hint == ""
|
||||
|
||||
|
||||
class TestWarmSessionTemplate:
|
||||
def test_creation(self, sample_template):
|
||||
assert sample_template.name == "test-template"
|
||||
assert len(sample_template.examples) == 3
|
||||
assert sample_template.created_at > 0
|
||||
|
||||
def test_round_trip_dict(self, sample_template):
|
||||
data = sample_template.to_dict()
|
||||
restored = WarmSessionTemplate.from_dict(data)
|
||||
assert restored.name == sample_template.name
|
||||
assert len(restored.examples) == len(sample_template.examples)
|
||||
assert restored.examples[0].tool_name == "terminal"
|
||||
|
||||
def test_from_dict_with_plain_dicts(self):
|
||||
data = {
|
||||
"name": "plain",
|
||||
"description": "from dict",
|
||||
"examples": [
|
||||
{
|
||||
"tool_name": "web_search",
|
||||
"arguments": {"query": "test"},
|
||||
"result_summary": "results found",
|
||||
"result_success": True,
|
||||
"context_hint": "",
|
||||
}
|
||||
],
|
||||
}
|
||||
template = WarmSessionTemplate.from_dict(data)
|
||||
assert len(template.examples) == 1
|
||||
assert template.examples[0].tool_name == "web_search"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Truncation
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestTruncateResult:
|
||||
def test_short_unchanged(self):
|
||||
assert _truncate_result("short text") == "short text"
|
||||
|
||||
def test_long_truncated(self):
|
||||
long = "x" * 1000
|
||||
result = _truncate_result(long, max_chars=100)
|
||||
assert len(result) < 200 # 100 chars + truncation suffix
|
||||
assert "truncated" in result
|
||||
|
||||
def test_empty(self):
|
||||
assert _truncate_result("") == ""
|
||||
assert _truncate_result(None) == ""
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Build conversation
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestBuildWarmConversation:
|
||||
def test_basic_conversation(self, sample_template):
|
||||
messages = build_warm_conversation(sample_template)
|
||||
# Each example produces: user + assistant(tool_calls) + tool(result) = 3 messages
|
||||
assert len(messages) == 3 * 3 # 3 examples * 3 messages each
|
||||
|
||||
def test_message_roles_alternate(self, sample_template):
|
||||
messages = build_warm_conversation(sample_template)
|
||||
roles = [m["role"] for m in messages]
|
||||
expected = ["user", "assistant", "tool"] * 3
|
||||
assert roles == expected
|
||||
|
||||
def test_tool_calls_have_ids(self, sample_template):
|
||||
messages = build_warm_conversation(sample_template)
|
||||
assistant_msgs = [m for m in messages if m["role"] == "assistant"]
|
||||
for msg in assistant_msgs:
|
||||
tc = msg["tool_calls"][0]
|
||||
assert tc["id"].startswith("warm_")
|
||||
assert tc["function"]["name"] in ("terminal", "read_file", "search_files")
|
||||
|
||||
def test_tool_results_reference_ids(self, sample_template):
|
||||
messages = build_warm_conversation(sample_template)
|
||||
assistant_msgs = [m for m in messages if m["role"] == "assistant"]
|
||||
tool_msgs = [m for m in messages if m["role"] == "tool"]
|
||||
for a, t in zip(assistant_msgs, tool_msgs):
|
||||
assert t["tool_call_id"] == a["tool_calls"][0]["id"]
|
||||
|
||||
def test_max_examples_limit(self, sample_template):
|
||||
messages = build_warm_conversation(sample_template, max_examples=1)
|
||||
assert len(messages) == 3 # 1 example * 3 messages
|
||||
|
||||
def test_system_prompt_addendum(self, sample_template):
|
||||
sample_template.system_prompt_addendum = "Use Python 3.12+"
|
||||
messages = build_warm_conversation(sample_template)
|
||||
assert messages[0]["role"] == "system"
|
||||
assert "Python 3.12+" in messages[0]["content"]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Save / Load / List
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestTemplatePersistence:
|
||||
def test_save_and_load(self, isolated_templates_dir, sample_template):
|
||||
save_template(sample_template)
|
||||
loaded = load_template("test-template")
|
||||
assert loaded is not None
|
||||
assert loaded.name == "test-template"
|
||||
assert len(loaded.examples) == 3
|
||||
|
||||
def test_load_nonexistent(self, isolated_templates_dir):
|
||||
assert load_template("does-not-exist") is None
|
||||
|
||||
def test_list_templates(self, isolated_templates_dir, sample_template):
|
||||
save_template(sample_template)
|
||||
templates = list_templates()
|
||||
assert len(templates) == 1
|
||||
assert templates[0]["name"] == "test-template"
|
||||
assert templates[0]["example_count"] == 3
|
||||
|
||||
def test_list_empty(self, isolated_templates_dir):
|
||||
assert list_templates() == []
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Extract patterns (mocked SessionDB)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestExtractPatterns:
|
||||
def test_extracts_from_marathon_sessions(self):
|
||||
db = MagicMock()
|
||||
db.list_sessions.return_value = [
|
||||
{"id": "s1", "message_count": 50, "end_reason": "completed"},
|
||||
{"id": "s2", "message_count": 10, "end_reason": "completed"}, # too short
|
||||
]
|
||||
db.get_messages.return_value = [
|
||||
{
|
||||
"role": "assistant",
|
||||
"content": None,
|
||||
"tool_calls": json.dumps([{
|
||||
"id": "tc1",
|
||||
"type": "function",
|
||||
"function": {"name": "terminal", "arguments": json.dumps({"command": "pwd"})},
|
||||
}]),
|
||||
},
|
||||
]
|
||||
|
||||
examples = extract_successful_patterns(db, min_messages=20)
|
||||
# Only s1 (50 msgs) qualifies, s2 (10 msgs) is skipped
|
||||
assert len(examples) == 1
|
||||
assert examples[0].tool_name == "terminal"
|
||||
|
||||
def test_skips_trivial_tools(self):
|
||||
db = MagicMock()
|
||||
db.list_sessions.return_value = [
|
||||
{"id": "s1", "message_count": 50, "end_reason": "completed"},
|
||||
]
|
||||
db.get_messages.return_value = [
|
||||
{
|
||||
"role": "assistant",
|
||||
"content": None,
|
||||
"tool_calls": json.dumps([{
|
||||
"id": "tc1",
|
||||
"type": "function",
|
||||
"function": {"name": "clarify", "arguments": "{}"},
|
||||
}]),
|
||||
},
|
||||
]
|
||||
|
||||
examples = extract_successful_patterns(db)
|
||||
assert len(examples) == 0 # clarify is trivial, skipped
|
||||
|
||||
def test_skips_errored_sessions(self):
|
||||
db = MagicMock()
|
||||
db.list_sessions.return_value = [
|
||||
{"id": "s1", "message_count": 50, "end_reason": "error"},
|
||||
]
|
||||
|
||||
examples = extract_successful_patterns(db)
|
||||
assert len(examples) == 0 # errored session, skipped
|
||||
@@ -1,63 +0,0 @@
|
||||
"""Tests for Qwen3.5:35B evaluation -- Issue #288."""
|
||||
|
||||
import json
|
||||
import pytest
|
||||
from scripts.evaluate_qwen35 import (
|
||||
ModelSpec, FLEET_MODELS, SECURITY_CRITERIA, HARDWARE_PROFILES,
|
||||
check_ollama_status, generate_report,
|
||||
)
|
||||
|
||||
|
||||
class TestModelSpec:
|
||||
def test_spec_fields(self):
|
||||
s = ModelSpec()
|
||||
assert s.name == "Qwen3.5-35B-A3B"
|
||||
assert s.total_params == "35B"
|
||||
assert s.active_params == "3B per token"
|
||||
assert s.context_length == 131072
|
||||
assert s.license == "Apache 2.0"
|
||||
assert s.tool_use_support is True
|
||||
|
||||
def test_quantization_decreasing_vram(self):
|
||||
s = ModelSpec()
|
||||
items = sorted(s.quantization_options.items(), key=lambda x: x[1])
|
||||
for i in range(1, len(items)):
|
||||
assert items[i][1] >= items[i-1][1]
|
||||
|
||||
|
||||
class TestSecurity:
|
||||
def test_scores_in_range(self):
|
||||
for c in SECURITY_CRITERIA:
|
||||
assert 1 <= c["score"] <= 10
|
||||
assert c["weight"] in ("CRITICAL", "HIGH", "MEDIUM")
|
||||
|
||||
def test_weighted_average(self):
|
||||
wm = {"CRITICAL": 3, "HIGH": 2, "MEDIUM": 1}
|
||||
tw = sum(wm[c["weight"]] for c in SECURITY_CRITERIA)
|
||||
ws = sum(c["score"] * wm[c["weight"]] for c in SECURITY_CRITERIA)
|
||||
assert ws / tw >= 7.0
|
||||
|
||||
|
||||
class TestHardware:
|
||||
def test_m2_ultra_fits(self):
|
||||
assert HARDWARE_PROFILES["mac_m2_ultra_192gb"]["fits_q4"] is True
|
||||
|
||||
def test_m1_doesnt_fit(self):
|
||||
assert HARDWARE_PROFILES["mac_m1_16gb"]["fits_q4"] is False
|
||||
|
||||
|
||||
class TestReport:
|
||||
def test_has_all_sections(self):
|
||||
r = generate_report()
|
||||
for s in ["Model Specification", "VRAM", "Hardware", "Security", "Fleet", "Recommendation"]:
|
||||
assert s in r, f"Missing: {s}"
|
||||
|
||||
def test_verdict_approved(self):
|
||||
assert "APPROVED" in generate_report()
|
||||
|
||||
|
||||
class TestOllama:
|
||||
def test_returns_dict(self):
|
||||
r = check_ollama_status()
|
||||
assert isinstance(r, dict)
|
||||
assert "running" in r
|
||||
178
tools/warm_session_tool.py
Normal file
178
tools/warm_session_tool.py
Normal file
@@ -0,0 +1,178 @@
|
||||
"""Warm Session Tool — manage pre-proficient agent sessions.
|
||||
|
||||
Allows the agent to build, save, list, and load warm session templates
|
||||
that pre-seed new sessions with successful tool-call patterns.
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
from typing import Optional
|
||||
|
||||
from tools.registry import registry
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def warm_session(
|
||||
action: str,
|
||||
name: str = None,
|
||||
description: str = "",
|
||||
min_messages: int = 20,
|
||||
max_sessions: int = 20,
|
||||
source_filter: str = None,
|
||||
tags: list = None,
|
||||
) -> str:
|
||||
"""Manage warm session templates for pre-proficient agent sessions.
|
||||
|
||||
Actions:
|
||||
build — mine existing sessions and create a template
|
||||
list — show saved templates
|
||||
load — return a template's conversation_history for injection
|
||||
delete — remove a template
|
||||
"""
|
||||
from agent.warm_session import (
|
||||
build_from_session_db,
|
||||
load_template,
|
||||
list_templates,
|
||||
build_warm_conversation,
|
||||
save_template,
|
||||
TEMPLATES_DIR,
|
||||
)
|
||||
|
||||
if action == "list":
|
||||
templates = list_templates()
|
||||
return json.dumps({
|
||||
"success": True,
|
||||
"templates": templates,
|
||||
"count": len(templates),
|
||||
})
|
||||
|
||||
if action == "build":
|
||||
if not name:
|
||||
return json.dumps({"success": False, "error": "name is required for 'build'."})
|
||||
|
||||
try:
|
||||
from hermes_state import SessionDB
|
||||
db = SessionDB()
|
||||
except Exception as e:
|
||||
return json.dumps({"success": False, "error": f"Cannot open session DB: {e}"})
|
||||
|
||||
template = build_from_session_db(
|
||||
db,
|
||||
name=name,
|
||||
description=description,
|
||||
min_messages=min_messages,
|
||||
max_sessions=max_sessions,
|
||||
source_filter=source_filter,
|
||||
tags=tags or [],
|
||||
)
|
||||
|
||||
return json.dumps({
|
||||
"success": True,
|
||||
"name": template.name,
|
||||
"example_count": len(template.examples),
|
||||
"description": template.description,
|
||||
})
|
||||
|
||||
if action == "load":
|
||||
if not name:
|
||||
return json.dumps({"success": False, "error": "name is required for 'load'."})
|
||||
|
||||
template = load_template(name)
|
||||
if not template:
|
||||
return json.dumps({"success": False, "error": f"Template '{name}' not found."})
|
||||
|
||||
conversation = build_warm_conversation(template)
|
||||
return json.dumps({
|
||||
"success": True,
|
||||
"name": template.name,
|
||||
"message_count": len(conversation),
|
||||
"conversation_preview": [
|
||||
{"role": m["role"], "content_preview": str(m.get("content", ""))[:100]}
|
||||
for m in conversation[:6]
|
||||
],
|
||||
})
|
||||
|
||||
if action == "delete":
|
||||
if not name:
|
||||
return json.dumps({"success": False, "error": "name is required for 'delete'."})
|
||||
|
||||
path = TEMPLATES_DIR / f"{name}.json"
|
||||
if not path.exists():
|
||||
return json.dumps({"success": False, "error": f"Template '{name}' not found."})
|
||||
|
||||
path.unlink()
|
||||
return json.dumps({"success": True, "message": f"Template '{name}' deleted."})
|
||||
|
||||
return json.dumps({
|
||||
"success": False,
|
||||
"error": f"Unknown action '{action}'. Use: build, list, load, delete",
|
||||
})
|
||||
|
||||
|
||||
WARM_SESSION_SCHEMA = {
|
||||
"name": "warm_session",
|
||||
"description": (
|
||||
"Manage warm session templates for pre-proficient agent sessions. "
|
||||
"Marathon sessions have lower error rates than mid-length ones because "
|
||||
"agents accumulate successful patterns. Warm templates capture those "
|
||||
"patterns and pre-seed new sessions with experience.\n\n"
|
||||
"Actions:\n"
|
||||
" build — mine existing sessions for successful tool-call patterns, save as template\n"
|
||||
" list — show saved templates\n"
|
||||
" load — retrieve a template's conversation history for session injection\n"
|
||||
" delete — remove a template"
|
||||
),
|
||||
"parameters": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"action": {
|
||||
"type": "string",
|
||||
"enum": ["build", "list", "load", "delete"],
|
||||
"description": "The action to perform.",
|
||||
},
|
||||
"name": {
|
||||
"type": "string",
|
||||
"description": "Template name. Required for build/load/delete.",
|
||||
},
|
||||
"description": {
|
||||
"type": "string",
|
||||
"description": "Description for the template. Used with 'build'.",
|
||||
},
|
||||
"min_messages": {
|
||||
"type": "integer",
|
||||
"description": "Minimum message count to consider a session experienced (default: 20).",
|
||||
},
|
||||
"max_sessions": {
|
||||
"type": "integer",
|
||||
"description": "Maximum sessions to scan when building (default: 20).",
|
||||
},
|
||||
"source_filter": {
|
||||
"type": "string",
|
||||
"description": "Filter sessions by source (cli, telegram, discord, etc.).",
|
||||
},
|
||||
"tags": {
|
||||
"type": "array",
|
||||
"items": {"type": "string"},
|
||||
"description": "Tags for organizing templates.",
|
||||
},
|
||||
},
|
||||
"required": ["action"],
|
||||
},
|
||||
}
|
||||
|
||||
registry.register(
|
||||
name="warm_session",
|
||||
toolset="skills",
|
||||
schema=WARM_SESSION_SCHEMA,
|
||||
handler=lambda args, **kw: warm_session(
|
||||
action=args.get("action", ""),
|
||||
name=args.get("name"),
|
||||
description=args.get("description", ""),
|
||||
min_messages=args.get("min_messages", 20),
|
||||
max_sessions=args.get("max_sessions", 20),
|
||||
source_filter=args.get("source_filter"),
|
||||
tags=args.get("tags"),
|
||||
),
|
||||
emoji="🔥",
|
||||
)
|
||||
Reference in New Issue
Block a user