Compare commits
1 Commits
burn/328-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
|
||||
@@ -127,54 +127,6 @@ class SessionResetPolicy:
|
||||
idle_minutes = data.get("idle_minutes")
|
||||
notify = data.get("notify")
|
||||
exclude = data.get("notify_exclude_platforms")
|
||||
|
||||
# --- Early validation: reject bad values before they reach runtime ---
|
||||
|
||||
# Validate idle_minutes: must be a positive integer, cap at 1 year
|
||||
if idle_minutes is not None:
|
||||
try:
|
||||
idle_minutes = int(idle_minutes)
|
||||
except (ValueError, TypeError):
|
||||
logger.warning(
|
||||
"Invalid idle_minutes=%r (not an integer). Using default 1440.",
|
||||
idle_minutes,
|
||||
)
|
||||
idle_minutes = None
|
||||
else:
|
||||
if idle_minutes <= 0:
|
||||
logger.warning(
|
||||
"Invalid idle_minutes=%s (must be positive). Using default 1440.",
|
||||
idle_minutes,
|
||||
)
|
||||
idle_minutes = None
|
||||
elif idle_minutes > 525600:
|
||||
logger.warning(
|
||||
"idle_minutes=%s exceeds 1 year. Capping at 525600.",
|
||||
idle_minutes,
|
||||
)
|
||||
idle_minutes = 525600
|
||||
|
||||
# Validate at_hour: must be 0-23
|
||||
if at_hour is not None:
|
||||
try:
|
||||
at_hour = int(at_hour)
|
||||
except (ValueError, TypeError):
|
||||
logger.warning("Invalid at_hour=%r (not an integer). Using default 4.", at_hour)
|
||||
at_hour = None
|
||||
else:
|
||||
if not (0 <= at_hour <= 23):
|
||||
logger.warning("Invalid at_hour=%s (must be 0-23). Using default 4.", at_hour)
|
||||
at_hour = None
|
||||
|
||||
# Validate mode
|
||||
if mode is not None:
|
||||
mode = str(mode).strip().lower()
|
||||
if mode not in ("daily", "idle", "both", "none"):
|
||||
logger.warning(
|
||||
"Invalid session_reset mode=%r. Using default 'both'.", mode
|
||||
)
|
||||
mode = None
|
||||
|
||||
return cls(
|
||||
mode=mode if mode is not None else "both",
|
||||
at_hour=at_hour if at_hour is not None else 4,
|
||||
@@ -604,8 +556,6 @@ def load_gateway_config() -> GatewayConfig:
|
||||
os.environ["DISCORD_AUTO_THREAD"] = str(discord_cfg["auto_thread"]).lower()
|
||||
if "reactions" in discord_cfg and not os.getenv("DISCORD_REACTIONS"):
|
||||
os.environ["DISCORD_REACTIONS"] = str(discord_cfg["reactions"]).lower()
|
||||
if "skill_slash_commands" in discord_cfg and not os.getenv("DISCORD_SKILL_SLASH_COMMANDS"):
|
||||
os.environ["DISCORD_SKILL_SLASH_COMMANDS"] = str(discord_cfg["skill_slash_commands"]).lower()
|
||||
|
||||
# Telegram settings → env vars (env vars take precedence)
|
||||
telegram_cfg = yaml_cfg.get("telegram", {})
|
||||
@@ -695,62 +645,6 @@ def load_gateway_config() -> GatewayConfig:
|
||||
platform.value, env_name,
|
||||
)
|
||||
|
||||
# --- API Server key validation ---
|
||||
# Error if the API server is bound to a non-localhost address without a key
|
||||
# (this is an open relay). Warn on localhost.
|
||||
if Platform.API_SERVER in config.platforms and config.platforms[Platform.API_SERVER].enabled:
|
||||
api_cfg = config.platforms[Platform.API_SERVER]
|
||||
host = api_cfg.extra.get("host", os.getenv("API_SERVER_HOST", "127.0.0.1"))
|
||||
key = api_cfg.extra.get("key", os.getenv("API_SERVER_KEY", ""))
|
||||
if not key:
|
||||
if host in ("0.0.0.0", "::", ""):
|
||||
logger.error(
|
||||
"API server is bound to %s without API_SERVER_KEY set. "
|
||||
"This exposes an unauthenticated OpenAI-compatible endpoint to the network. "
|
||||
"Set API_SERVER_KEY immediately or bind to 127.0.0.1.",
|
||||
host,
|
||||
)
|
||||
else:
|
||||
logger.warning(
|
||||
"API server is enabled without API_SERVER_KEY. "
|
||||
"All requests will be unauthenticated. "
|
||||
"Set API_SERVER_KEY for production use.",
|
||||
)
|
||||
|
||||
# --- Provider fallback validation ---
|
||||
# Warn if fallback_model references a provider whose API key is not set
|
||||
try:
|
||||
import yaml as _yaml
|
||||
_config_yaml_path = get_hermes_home() / "config.yaml"
|
||||
if _config_yaml_path.exists():
|
||||
with open(_config_yaml_path, encoding="utf-8") as _f:
|
||||
_raw_cfg = _yaml.safe_load(_f) or {}
|
||||
_fallback = _raw_cfg.get("fallback_model")
|
||||
if isinstance(_fallback, dict):
|
||||
_fb_provider = (_fallback.get("provider") or "").lower().strip()
|
||||
if _fb_provider == "openrouter" and not os.getenv("OPENROUTER_API_KEY"):
|
||||
logger.warning(
|
||||
"fallback_model uses provider 'openrouter' but OPENROUTER_API_KEY is not set. "
|
||||
"Fallback will fail at runtime. Set the key or change the fallback provider.",
|
||||
)
|
||||
elif _fb_provider in ("anthropic", "claude") and not os.getenv("ANTHROPIC_API_KEY"):
|
||||
logger.warning(
|
||||
"fallback_model uses provider '%s' but ANTHROPIC_API_KEY is not set. "
|
||||
"Fallback will fail at runtime.", _fb_provider,
|
||||
)
|
||||
elif _fb_provider == "openai" and not os.getenv("OPENAI_API_KEY"):
|
||||
logger.warning(
|
||||
"fallback_model uses provider 'openai' but OPENAI_API_KEY is not set. "
|
||||
"Fallback will fail at runtime.",
|
||||
)
|
||||
elif _fb_provider in ("nous", "nousresearch") and not os.getenv("NOUS_API_KEY"):
|
||||
logger.warning(
|
||||
"fallback_model uses provider '%s' but NOUS_API_KEY is not set. "
|
||||
"Fallback will fail at runtime.", _fb_provider,
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return config
|
||||
|
||||
|
||||
@@ -773,10 +667,6 @@ _MIN_TOKEN_LENGTHS = {
|
||||
"DISCORD_BOT_TOKEN": 50,
|
||||
"SLACK_BOT_TOKEN": 20,
|
||||
"HASS_TOKEN": 20,
|
||||
"OPENROUTER_API_KEY": 20,
|
||||
"ANTHROPIC_API_KEY": 20,
|
||||
"OPENAI_API_KEY": 20,
|
||||
"NOUS_API_KEY": 20,
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -1623,19 +1623,6 @@ class APIServerAdapter(BasePlatformAdapter):
|
||||
"[%s] API server listening on http://%s:%d",
|
||||
self.name, self._host, self._port,
|
||||
)
|
||||
if not self._api_key:
|
||||
if self._host in ("0.0.0.0", "::", ""):
|
||||
logger.error(
|
||||
"[%s] No API_SERVER_KEY set and bound to %s — "
|
||||
"endpoint is unauthenticated on the network. "
|
||||
"Set API_SERVER_KEY or bind to 127.0.0.1.",
|
||||
self.name, self._host,
|
||||
)
|
||||
else:
|
||||
logger.warning(
|
||||
"[%s] No API_SERVER_KEY set — all requests are unauthenticated.",
|
||||
self.name,
|
||||
)
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
|
||||
@@ -1698,59 +1698,43 @@ class DiscordAdapter(BasePlatformAdapter):
|
||||
# Register installed skills as native slash commands (parity with
|
||||
# Telegram, which uses telegram_menu_commands() in commands.py).
|
||||
# Discord allows up to 100 application commands globally.
|
||||
#
|
||||
# Config: set DISCORD_SKILL_SLASH_COMMANDS=false to disable skill
|
||||
# slash commands entirely — useful when 279+ skills overflow the
|
||||
# 100-command limit. Skills remain accessible via /skill or text mention.
|
||||
_skill_slash_enabled = os.getenv("DISCORD_SKILL_SLASH_COMMANDS", "true").lower()
|
||||
_skill_slash_enabled = _skill_slash_enabled not in ("false", "0", "no", "off")
|
||||
_DISCORD_CMD_LIMIT = 100
|
||||
try:
|
||||
from hermes_cli.commands import discord_skill_commands
|
||||
|
||||
if not _skill_slash_enabled:
|
||||
logger.info(
|
||||
"[%s] Discord skill slash commands disabled (DISCORD_SKILL_SLASH_COMMANDS=false). "
|
||||
"Skills accessible via /skill or text mention.",
|
||||
self.name,
|
||||
existing_names = {cmd.name for cmd in tree.get_commands()}
|
||||
remaining_slots = max(0, _DISCORD_CMD_LIMIT - len(existing_names))
|
||||
|
||||
skill_entries, skipped = discord_skill_commands(
|
||||
max_slots=remaining_slots,
|
||||
reserved_names=existing_names,
|
||||
)
|
||||
else:
|
||||
_DISCORD_CMD_LIMIT = 100
|
||||
try:
|
||||
from hermes_cli.commands import discord_skill_commands
|
||||
|
||||
existing_names = {cmd.name for cmd in tree.get_commands()}
|
||||
remaining_slots = max(0, _DISCORD_CMD_LIMIT - len(existing_names))
|
||||
for discord_name, description, cmd_key in skill_entries:
|
||||
# Closure factory to capture cmd_key per iteration
|
||||
def _make_skill_handler(_key: str):
|
||||
async def _skill_slash(interaction: discord.Interaction, args: str = ""):
|
||||
await self._run_simple_slash(interaction, f"{_key} {args}".strip())
|
||||
return _skill_slash
|
||||
|
||||
skill_entries, skipped = discord_skill_commands(
|
||||
max_slots=remaining_slots,
|
||||
reserved_names=existing_names,
|
||||
handler = _make_skill_handler(cmd_key)
|
||||
handler.__name__ = f"skill_{discord_name.replace('-', '_')}"
|
||||
|
||||
cmd = discord.app_commands.Command(
|
||||
name=discord_name,
|
||||
description=description,
|
||||
callback=handler,
|
||||
)
|
||||
discord.app_commands.describe(args="Optional arguments for the skill")(cmd)
|
||||
tree.add_command(cmd)
|
||||
|
||||
for discord_name, description, cmd_key in skill_entries:
|
||||
# Closure factory to capture cmd_key per iteration
|
||||
def _make_skill_handler(_key: str):
|
||||
async def _skill_slash(interaction: discord.Interaction, args: str = ""):
|
||||
await self._run_simple_slash(interaction, f"{_key} {args}".strip())
|
||||
return _skill_slash
|
||||
|
||||
handler = _make_skill_handler(cmd_key)
|
||||
handler.__name__ = f"skill_{discord_name.replace('-', '_')}"
|
||||
|
||||
cmd = discord.app_commands.Command(
|
||||
name=discord_name,
|
||||
description=description,
|
||||
callback=handler,
|
||||
)
|
||||
discord.app_commands.describe(args="Optional arguments for the skill")(cmd)
|
||||
tree.add_command(cmd)
|
||||
|
||||
if skipped:
|
||||
logger.warning(
|
||||
"[%s] Discord slash command limit reached (%d): %d skill(s) not registered. "
|
||||
"Set DISCORD_SKILL_SLASH_COMMANDS=false to disable skill slash commands "
|
||||
"and use /skill or text mentions instead.",
|
||||
self.name, _DISCORD_CMD_LIMIT, skipped,
|
||||
)
|
||||
except Exception as exc:
|
||||
logger.warning("[%s] Failed to register skill slash commands: %s", self.name, exc)
|
||||
if skipped:
|
||||
logger.warning(
|
||||
"[%s] Discord slash command limit reached (%d): %d skill(s) not registered",
|
||||
self.name, _DISCORD_CMD_LIMIT, skipped,
|
||||
)
|
||||
except Exception as exc:
|
||||
logger.warning("[%s] Failed to register skill slash commands: %s", self.name, exc)
|
||||
|
||||
def _build_slash_event(self, interaction: discord.Interaction, text: str) -> MessageEvent:
|
||||
"""Build a MessageEvent from a Discord slash command interaction."""
|
||||
|
||||
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,176 +0,0 @@
|
||||
"""Tests for gateway config debt fixes — issue #328."""
|
||||
|
||||
import os
|
||||
import logging
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
|
||||
from gateway.config import (
|
||||
SessionResetPolicy,
|
||||
GatewayConfig,
|
||||
Platform,
|
||||
_MIN_TOKEN_LENGTHS,
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# SessionResetPolicy.from_dict validation
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestIdleMinutesValidation:
|
||||
"""idle_minutes=0 was the #1 audit finding — it must be rejected at construction."""
|
||||
|
||||
def test_valid_value(self):
|
||||
p = SessionResetPolicy.from_dict({"idle_minutes": 30})
|
||||
assert p.idle_minutes == 30
|
||||
|
||||
def test_zero_rejected(self):
|
||||
p = SessionResetPolicy.from_dict({"idle_minutes": 0})
|
||||
assert p.idle_minutes == 1440
|
||||
|
||||
def test_negative_rejected(self):
|
||||
p = SessionResetPolicy.from_dict({"idle_minutes": -10})
|
||||
assert p.idle_minutes == 1440
|
||||
|
||||
def test_string_rejected(self):
|
||||
p = SessionResetPolicy.from_dict({"idle_minutes": "abc"})
|
||||
assert p.idle_minutes == 1440
|
||||
|
||||
def test_float_string_rejected(self):
|
||||
p = SessionResetPolicy.from_dict({"idle_minutes": "3.5"})
|
||||
assert p.idle_minutes == 1440
|
||||
|
||||
def test_absurd_value_capped(self):
|
||||
p = SessionResetPolicy.from_dict({"idle_minutes": 9999999})
|
||||
assert p.idle_minutes == 525600
|
||||
|
||||
def test_exactly_one_year_ok(self):
|
||||
p = SessionResetPolicy.from_dict({"idle_minutes": 525600})
|
||||
assert p.idle_minutes == 525600
|
||||
|
||||
def test_none_uses_default(self):
|
||||
p = SessionResetPolicy.from_dict({"idle_minutes": None})
|
||||
assert p.idle_minutes == 1440
|
||||
|
||||
def test_missing_uses_default(self):
|
||||
p = SessionResetPolicy.from_dict({})
|
||||
assert p.idle_minutes == 1440
|
||||
|
||||
|
||||
class TestAtHourValidation:
|
||||
def test_valid(self):
|
||||
for h in (0, 4, 12, 23):
|
||||
p = SessionResetPolicy.from_dict({"at_hour": h})
|
||||
assert p.at_hour == h
|
||||
|
||||
def test_out_of_range(self):
|
||||
p = SessionResetPolicy.from_dict({"at_hour": 25})
|
||||
assert p.at_hour == 4
|
||||
|
||||
def test_negative(self):
|
||||
p = SessionResetPolicy.from_dict({"at_hour": -1})
|
||||
assert p.at_hour == 4
|
||||
|
||||
def test_string(self):
|
||||
p = SessionResetPolicy.from_dict({"at_hour": "noon"})
|
||||
assert p.at_hour == 4
|
||||
|
||||
|
||||
class TestModeValidation:
|
||||
def test_valid_modes(self):
|
||||
for m in ("daily", "idle", "both", "none"):
|
||||
p = SessionResetPolicy.from_dict({"mode": m})
|
||||
assert p.mode == m
|
||||
|
||||
def test_invalid_mode(self):
|
||||
p = SessionResetPolicy.from_dict({"mode": "invalid"})
|
||||
assert p.mode == "both"
|
||||
|
||||
def test_case_insensitive(self):
|
||||
p = SessionResetPolicy.from_dict({"mode": "DAILY"})
|
||||
assert p.mode == "daily"
|
||||
|
||||
|
||||
class TestSessionResetPolicyDefaults:
|
||||
def test_all_defaults(self):
|
||||
p = SessionResetPolicy.from_dict({})
|
||||
assert p.mode == "both"
|
||||
assert p.at_hour == 4
|
||||
assert p.idle_minutes == 1440
|
||||
assert p.notify is True
|
||||
assert p.notify_exclude_platforms == ("api_server", "webhook")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Weak credential expansion
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestWeakCredentialExpansion:
|
||||
def test_provider_keys_in_min_lengths(self):
|
||||
assert "OPENROUTER_API_KEY" in _MIN_TOKEN_LENGTHS
|
||||
assert _MIN_TOKEN_LENGTHS["OPENROUTER_API_KEY"] == 20
|
||||
assert "ANTHROPIC_API_KEY" in _MIN_TOKEN_LENGTHS
|
||||
assert "OPENAI_API_KEY" in _MIN_TOKEN_LENGTHS
|
||||
assert "NOUS_API_KEY" in _MIN_TOKEN_LENGTHS
|
||||
|
||||
def test_existing_keys_preserved(self):
|
||||
assert "TELEGRAM_BOT_TOKEN" in _MIN_TOKEN_LENGTHS
|
||||
assert "DISCORD_BOT_TOKEN" in _MIN_TOKEN_LENGTHS
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# API server key validation
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestAPIServerKeyValidation:
|
||||
"""Validate that load_gateway_config warns about missing API keys."""
|
||||
|
||||
def test_warns_no_key_on_0000(self, caplog):
|
||||
with patch.dict(os.environ, {
|
||||
"API_SERVER_ENABLED": "true",
|
||||
"API_SERVER_HOST": "0.0.0.0",
|
||||
}, clear=False):
|
||||
os.environ.pop("API_SERVER_KEY", None)
|
||||
os.environ["API_SERVER_ENABLED"] = "true"
|
||||
os.environ["API_SERVER_HOST"] = "0.0.0.0"
|
||||
with caplog.at_level(logging.ERROR):
|
||||
config = load_gateway_config()
|
||||
assert any(
|
||||
"API_SERVER_KEY" in r.message
|
||||
for r in caplog.records
|
||||
if r.levelno >= logging.ERROR
|
||||
)
|
||||
|
||||
def test_warns_no_key_on_localhost(self, caplog):
|
||||
with patch.dict(os.environ, {
|
||||
"API_SERVER_ENABLED": "true",
|
||||
"API_SERVER_HOST": "127.0.0.1",
|
||||
}, clear=False):
|
||||
os.environ.pop("API_SERVER_KEY", None)
|
||||
os.environ["API_SERVER_ENABLED"] = "true"
|
||||
os.environ["API_SERVER_HOST"] = "127.0.0.1"
|
||||
with caplog.at_level(logging.WARNING):
|
||||
config = load_gateway_config()
|
||||
# Should get a warning (not error) on localhost
|
||||
assert any(
|
||||
"API_SERVER_KEY" in r.message
|
||||
for r in caplog.records
|
||||
if r.levelno >= logging.WARNING
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Discord skill slash commands config bridge
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestDiscordSkillConfigBridge:
|
||||
"""Verify discord.skill_slash_commands config.yaml key maps to env var."""
|
||||
|
||||
def test_env_var_recognized(self):
|
||||
# The adapter checks DISCORD_SKILL_SLASH_COMMANDS env var
|
||||
# We just verify the env var name is correct
|
||||
with patch.dict(os.environ, {"DISCORD_SKILL_SLASH_COMMANDS": "false"}):
|
||||
val = os.getenv("DISCORD_SKILL_SLASH_COMMANDS", "true").lower()
|
||||
assert val == "false"
|
||||
assert val in ("false", "0", "no", "off")
|
||||
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