Compare commits
1 Commits
am/322-177
...
claude/iss
| Author | SHA1 | Date | |
|---|---|---|---|
|
a90162bafc |
178
agent/memory.py
178
agent/memory.py
@@ -1,178 +0,0 @@
|
||||
"""Memory backends — cross-session user modeling.
|
||||
|
||||
Local SQLite (sovereign, A grade 95pts) vs Honcho cloud (B grade 60pts).
|
||||
Recommendation: local for sovereignty.
|
||||
"""
|
||||
|
||||
import json, logging, os, sqlite3, time
|
||||
from abc import ABC, abstractmethod
|
||||
from dataclasses import dataclass, field
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional
|
||||
|
||||
from hermes_constants import get_hermes_home
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
@dataclass
|
||||
class Entry:
|
||||
key: str; value: str; uid: str
|
||||
etype: str = "preference"; created: float = 0; updated: float = 0; meta: Dict = field(default_factory=dict)
|
||||
def __post_init__(self):
|
||||
t = time.time()
|
||||
if not self.created: self.created = t
|
||||
if not self.updated: self.updated = t
|
||||
|
||||
class Backend(ABC):
|
||||
@abstractmethod
|
||||
def ok(self) -> bool: ...
|
||||
def put(self, uid: str, k: str, v: str, meta: Dict = None) -> bool: ...
|
||||
def get(self, uid: str, k: str) -> Optional[Entry]: ...
|
||||
def find(self, uid: str, q: str, n: int = 10) -> List[Entry]: ...
|
||||
def all(self, uid: str) -> List[Entry]: ...
|
||||
def rm(self, uid: str, k: str) -> bool: ...
|
||||
@property
|
||||
@abstractmethod
|
||||
def name(self) -> str: ...
|
||||
@property
|
||||
@abstractmethod
|
||||
def cloud(self) -> bool: ...
|
||||
|
||||
class Null(Backend):
|
||||
def ok(self) -> bool: return True
|
||||
def put(self, uid, k, v, meta=None) -> bool: return True
|
||||
def get(self, uid, k) -> Optional[Entry]: return None
|
||||
def find(self, uid, q, n=10) -> List[Entry]: return []
|
||||
def all(self, uid) -> List[Entry]: return []
|
||||
def rm(self, uid, k) -> bool: return True
|
||||
@property
|
||||
def name(self) -> str: return "null"
|
||||
@property
|
||||
def cloud(self) -> bool: return False
|
||||
|
||||
class Local(Backend):
|
||||
def __init__(self, p: Path = None):
|
||||
self._p = p or get_hermes_home() / "memory.db"
|
||||
self._p.parent.mkdir(parents=True, exist_ok=True)
|
||||
with sqlite3.connect(str(self._p)) as c:
|
||||
c.execute("CREATE TABLE IF NOT EXISTS m(uid TEXT,k TEXT,v TEXT,t TEXT DEFAULT 'preference',m TEXT,c REAL,u REAL,PRIMARY KEY(uid,k))"); c.commit()
|
||||
def ok(self) -> bool:
|
||||
try:
|
||||
with sqlite3.connect(str(self._p)) as c: c.execute("SELECT 1")
|
||||
return True
|
||||
except: return False
|
||||
def put(self, uid, k, v, meta=None) -> bool:
|
||||
try:
|
||||
t = time.time(); et = (meta or {}).get("type", "preference")
|
||||
with sqlite3.connect(str(self._p)) as c:
|
||||
c.execute("INSERT INTO m VALUES(?,?,?,?,?,?,?) ON CONFLICT(uid,k) DO UPDATE SET v=excluded.v,t=excluded.t,m=excluded.m,u=excluded.u",
|
||||
(uid, k, v, et, json.dumps(meta) if meta else None, t, t)); c.commit()
|
||||
return True
|
||||
except Exception as e: logger.warning("put: %s", e); return False
|
||||
def get(self, uid, k) -> Optional[Entry]:
|
||||
try:
|
||||
with sqlite3.connect(str(self._p)) as c:
|
||||
r = c.execute("SELECT k,v,uid,t,m,c,u FROM m WHERE uid=? AND k=?", (uid, k)).fetchone()
|
||||
return Entry(key=r[0], value=r[1], uid=r[2], etype=r[3], meta=json.loads(r[4]) if r[4] else {}, created=r[5], updated=r[6]) if r else None
|
||||
except: return None
|
||||
def find(self, uid, q, n=10) -> List[Entry]:
|
||||
try:
|
||||
p = f"%{q}%"
|
||||
with sqlite3.connect(str(self._p)) as c:
|
||||
rows = c.execute("SELECT k,v,uid,t,m,c,u FROM m WHERE uid=? AND (k LIKE ? OR v LIKE ?) ORDER BY u DESC LIMIT ?", (uid, p, p, n)).fetchall()
|
||||
return [Entry(key=r[0], value=r[1], uid=r[2], etype=r[3], meta=json.loads(r[4]) if r[4] else {}, created=r[5], updated=r[6]) for r in rows]
|
||||
except: return []
|
||||
def all(self, uid) -> List[Entry]:
|
||||
try:
|
||||
with sqlite3.connect(str(self._p)) as c:
|
||||
rows = c.execute("SELECT k,v,uid,t,m,c,u FROM m WHERE uid=? ORDER BY u DESC", (uid,)).fetchall()
|
||||
return [Entry(key=r[0], value=r[1], uid=r[2], etype=r[3], meta=json.loads(r[4]) if r[4] else {}, created=r[5], updated=r[6]) for r in rows]
|
||||
except: return []
|
||||
def rm(self, uid, k) -> bool:
|
||||
try:
|
||||
with sqlite3.connect(str(self._p)) as c: c.execute("DELETE FROM m WHERE uid=? AND k=?", (uid, k)); c.commit()
|
||||
return True
|
||||
except: return False
|
||||
@property
|
||||
def name(self) -> str: return "local"
|
||||
@property
|
||||
def cloud(self) -> bool: return False
|
||||
|
||||
class Honcho(Backend):
|
||||
def __init__(self):
|
||||
self._c = None; self._k = os.getenv("HONCHO_API_KEY", "")
|
||||
def _lazy(self):
|
||||
if self._c: return self._c
|
||||
if not self._k: return None
|
||||
try:
|
||||
from honcho import Honcho as H; self._c = H(api_key=self._k); return self._c
|
||||
except: return None
|
||||
def ok(self) -> bool:
|
||||
if not self._k: return False
|
||||
c = self._lazy()
|
||||
if not c: return False
|
||||
try: c.get_sessions(limit=1); return True
|
||||
except: return False
|
||||
def put(self, uid, k, v, meta=None) -> bool:
|
||||
c = self._lazy()
|
||||
if not c: return False
|
||||
try: c.add_message(f"m-{uid}", "system", json.dumps({"k": k, "v": v})); return True
|
||||
except: return False
|
||||
def get(self, uid, k) -> Optional[Entry]:
|
||||
for e in self.find(uid, k, 1):
|
||||
if e.key == k: return e
|
||||
return None
|
||||
def find(self, uid, q, n=10) -> List[Entry]:
|
||||
c = self._lazy()
|
||||
if not c: return []
|
||||
try:
|
||||
r = c.chat(f"m-{uid}", f"Find: {q}")
|
||||
if isinstance(r, dict):
|
||||
try:
|
||||
data = json.loads(r.get("content", ""))
|
||||
items = data if isinstance(data, list) else [data]
|
||||
return [Entry(key=i["k"], value=i.get("v", ""), uid=uid) for i in items[:n] if isinstance(i, dict) and i.get("k")]
|
||||
except: pass
|
||||
return []
|
||||
except: return []
|
||||
def all(self, uid) -> List[Entry]: return self.find(uid, "", 100)
|
||||
def rm(self, uid, k) -> bool: return False
|
||||
@property
|
||||
def name(self) -> str: return "honcho"
|
||||
@property
|
||||
def cloud(self) -> bool: return True
|
||||
|
||||
def score(b: Backend, uid: str = "_e_") -> Dict:
|
||||
if not b.ok(): return {"name": b.name, "score": 0, "grade": "F", "ok": False, "cloud": b.cloud}
|
||||
s = 20
|
||||
t0 = time.perf_counter(); ok = b.put(uid, "ek", "ev"); sm = (time.perf_counter()-t0)*1000; s += 15 if ok else 0
|
||||
t0 = time.perf_counter(); r = b.get(uid, "ek"); gm = (time.perf_counter()-t0)*1000; s += 15 if r else 0
|
||||
t0 = time.perf_counter(); q = b.find(uid, "ev", 5); qm = (time.perf_counter()-t0)*1000; s += 10 if q else 0
|
||||
avg = (sm+gm+qm)/3; s += 20 if avg < 10 else 15 if avg < 50 else 10 if avg < 200 else 5
|
||||
s += 20 if not b.cloud else 5
|
||||
try: b.rm(uid, "ek")
|
||||
except: pass
|
||||
g = "A" if s >= 80 else "B" if s >= 60 else "C" if s >= 40 else "D" if s >= 20 else "F"
|
||||
return {"name": b.name, "score": s, "grade": g, "ok": True, "cloud": b.cloud}
|
||||
|
||||
def evaluate() -> Dict:
|
||||
bs = [Null(), Local()]
|
||||
if os.getenv("HONCHO_API_KEY"):
|
||||
try: bs.append(Honcho())
|
||||
except: pass
|
||||
rs = [score(b) for b in bs]
|
||||
best = max((r for r in rs if r["name"] != "null" and r["ok"]), key=lambda r: r["score"], default=None)
|
||||
rec = f"Best: {best['name']} ({best['score']}pts, {best['grade']})" if best else "None"
|
||||
if best and best.get("cloud"): rec += " WARNING: cloud. RECOMMEND local."
|
||||
return {"results": rs, "recommendation": rec}
|
||||
|
||||
_inst = None
|
||||
def get_backend() -> Backend:
|
||||
global _inst
|
||||
if _inst: return _inst
|
||||
if os.getenv("HONCHO_API_KEY") and os.getenv("HERMES_MEMORY_BACKEND", "").lower() != "local":
|
||||
try:
|
||||
h = Honcho()
|
||||
if h.ok(): _inst = h; return _inst
|
||||
except: pass
|
||||
_inst = Local(); return _inst
|
||||
def reset(): global _inst; _inst = None
|
||||
@@ -32,6 +32,27 @@ _PROVIDER_PREFIXES: frozenset[str] = frozenset({
|
||||
"glm", "z-ai", "z.ai", "zhipu", "github", "github-copilot",
|
||||
"github-models", "kimi", "moonshot", "claude", "deep-seek",
|
||||
"opencode", "zen", "go", "vercel", "kilo", "dashscope", "aliyun", "qwen",
|
||||
# Additional cloud vendor prefixes (fixes #628)
|
||||
"cohere", "mistralai", "mistral", "meta-llama", "databricks", "together",
|
||||
"togetherai", "together-ai", "nousresearch", "moonshotai", "fireworks",
|
||||
"perplexity", "ai21", "groq", "cerebras", "nebius",
|
||||
})
|
||||
|
||||
# Vendor prefixes that appear in cloud model IDs (e.g. "openai/gpt-4").
|
||||
# Used by _classify_runtime to detect cloud runtimes from the model name
|
||||
# when no base URL is available.
|
||||
_CLOUD_MODEL_PREFIXES: frozenset[str] = frozenset({
|
||||
# Providers present before #628
|
||||
"nous", "nousresearch", "openrouter", "anthropic", "openai",
|
||||
"zai", "kimi", "moonshotai", "gemini", "google", "minimax",
|
||||
# Providers added by #628 fix
|
||||
"deepseek", "cohere", "mistralai", "mistral", "meta-llama",
|
||||
"databricks", "together", "togetherai",
|
||||
# Other common cloud vendors
|
||||
"microsoft", "amazon", "huggingface", "fireworks",
|
||||
"perplexity", "ai21", "groq", "cerebras", "nebius",
|
||||
"qwen", "alibaba", "aliyuncs", "dashscope",
|
||||
"github", "copilot",
|
||||
})
|
||||
|
||||
|
||||
@@ -253,6 +274,67 @@ def is_local_endpoint(base_url: str) -> bool:
|
||||
return False
|
||||
|
||||
|
||||
# Provider names that are definitively local (never cloud).
|
||||
_LOCAL_PROVIDER_NAMES: frozenset[str] = frozenset({
|
||||
"ollama", "custom", "local",
|
||||
})
|
||||
|
||||
# Provider names that are definitively cloud (not local).
|
||||
_CLOUD_PROVIDER_NAMES: frozenset[str] = frozenset({
|
||||
"nous", "openrouter", "anthropic", "openai", "openai-codex",
|
||||
"zai", "kimi-coding", "gemini", "minimax", "minimax-cn",
|
||||
"deepseek", "cohere", "mistral", "meta-llama", "databricks", "together",
|
||||
"huggingface", "copilot", "copilot-acp", "ai-gateway", "kilocode",
|
||||
"alibaba", "opencode-zen", "opencode-go",
|
||||
})
|
||||
|
||||
|
||||
def _classify_runtime(
|
||||
model: str = "",
|
||||
base_url: str = "",
|
||||
provider: str = "",
|
||||
) -> str:
|
||||
"""Classify a model/endpoint runtime as 'cloud' or 'local'.
|
||||
|
||||
Checks in priority order:
|
||||
1. ``base_url`` — localhost / RFC-1918 → ``"local"``; known external URL → ``"cloud"``
|
||||
2. ``provider`` name — matches a known local or cloud provider set
|
||||
3. Model vendor prefix — e.g. ``"openai/gpt-4"`` → ``"cloud"``
|
||||
4. Default — ``"cloud"`` when the runtime cannot be determined to be local
|
||||
|
||||
The cloud-prefix list covers both the providers present before issue #628
|
||||
(nous, openrouter, anthropic, openai, zai, kimi, gemini, minimax) and the
|
||||
previously missing ones (deepseek, cohere, mistral, meta-llama, databricks,
|
||||
together).
|
||||
|
||||
Returns ``"cloud"`` or ``"local"``.
|
||||
"""
|
||||
# 1. URL-based check — most reliable signal
|
||||
if base_url:
|
||||
if is_local_endpoint(base_url):
|
||||
return "local"
|
||||
return "cloud"
|
||||
|
||||
# 2. Provider name check
|
||||
provider_norm = (provider or "").strip().lower()
|
||||
if provider_norm in _LOCAL_PROVIDER_NAMES:
|
||||
return "local"
|
||||
if provider_norm in _CLOUD_PROVIDER_NAMES:
|
||||
return "cloud"
|
||||
|
||||
# 3. Model vendor prefix check (e.g. "openai/gpt-4" → vendor "openai")
|
||||
model_norm = (model or "").strip().lower()
|
||||
if "/" in model_norm:
|
||||
vendor = model_norm.split("/")[0].strip()
|
||||
if vendor in _CLOUD_MODEL_PREFIXES:
|
||||
return "cloud"
|
||||
# An unknown vendor with a slash is still likely a cloud model
|
||||
return "cloud"
|
||||
|
||||
# 4. Default — without a URL we cannot confirm local, so assume cloud
|
||||
return "cloud"
|
||||
|
||||
|
||||
def detect_local_server_type(base_url: str) -> Optional[str]:
|
||||
"""Detect which local server is running at base_url by probing known endpoints.
|
||||
|
||||
|
||||
@@ -1,61 +0,0 @@
|
||||
"""Tests for memory backends (#322)."""
|
||||
import json, pytest
|
||||
from agent.memory import Entry, Null, Local, Honcho, score, evaluate, get_backend, reset
|
||||
|
||||
@pytest.fixture()
|
||||
def loc(tmp_path): return Local(p=tmp_path/"t.db")
|
||||
@pytest.fixture()
|
||||
def rst(): reset(); yield; reset()
|
||||
|
||||
class TestEntry:
|
||||
def test_defaults(self):
|
||||
e=Entry(key="k",value="v",uid="u"); assert e.created>0
|
||||
|
||||
class TestNull:
|
||||
def test_ok(self): assert Null().ok()
|
||||
def test_put(self): assert Null().put("u","k","v")
|
||||
def test_get(self): assert Null().get("u","k") is None
|
||||
def test_find(self): assert Null().find("u","q")==[]
|
||||
def test_all(self): assert Null().all("u")==[]
|
||||
def test_rm(self): assert Null().rm("u","k")
|
||||
def test_not_cloud(self): assert not Null().cloud
|
||||
|
||||
class TestLocal:
|
||||
def test_ok(self,loc): assert loc.ok()
|
||||
def test_put_get(self,loc):
|
||||
assert loc.put("u","lang","py")
|
||||
assert loc.get("u","lang").value=="py"
|
||||
def test_meta(self,loc):
|
||||
loc.put("u","k","v",{"type":"pattern"})
|
||||
assert loc.get("u","k").etype=="pattern"
|
||||
def test_update(self,loc):
|
||||
loc.put("u","k","v1"); loc.put("u","k","v2")
|
||||
assert loc.get("u","k").value=="v2"
|
||||
def test_find(self,loc):
|
||||
loc.put("u","pref_py","1"); loc.put("u","pref_vim","1"); loc.put("u","th","d")
|
||||
assert len(loc.find("u","pref"))==2
|
||||
def test_all(self,loc):
|
||||
loc.put("u","a","1"); loc.put("u","b","2"); assert len(loc.all("u"))==2
|
||||
def test_rm(self,loc):
|
||||
loc.put("u","k","v"); assert loc.rm("u","k"); assert loc.get("u","k") is None
|
||||
def test_not_cloud(self,loc): assert not loc.cloud
|
||||
def test_users(self,loc):
|
||||
loc.put("u1","k","v1"); loc.put("u2","k","v2")
|
||||
assert loc.get("u1","k").value=="v1"
|
||||
|
||||
class TestHoncho:
|
||||
def test_no_key(self,monkeypatch):
|
||||
monkeypatch.delenv("HONCHO_API_KEY",raising=False); assert not Honcho().ok()
|
||||
def test_cloud(self): assert Honcho().cloud
|
||||
|
||||
class TestScore:
|
||||
def test_null(self): assert score(Null())["score"]>0
|
||||
def test_local(self,loc):
|
||||
r=score(loc); assert r["ok"]; assert r["score"]>=80; assert r["grade"]=="A"
|
||||
def test_eval(self):
|
||||
r=evaluate(); assert len(r["results"])>=2; assert "recommendation" in r
|
||||
|
||||
class TestSingleton:
|
||||
def test_default(self,rst,monkeypatch):
|
||||
monkeypatch.delenv("HONCHO_API_KEY",raising=False); assert isinstance(get_backend(),Local)
|
||||
def test_cache(self,rst): assert get_backend() is get_backend()
|
||||
@@ -7,7 +7,7 @@ terminal access.
|
||||
"""
|
||||
|
||||
import pytest
|
||||
from agent.model_metadata import is_local_endpoint
|
||||
from agent.model_metadata import is_local_endpoint, _classify_runtime
|
||||
|
||||
|
||||
class TestIsLocalEndpoint:
|
||||
@@ -71,3 +71,98 @@ class TestCronDisabledToolsetsLogic:
|
||||
def test_empty_url_disables_terminal(self):
|
||||
disabled = self._build_disabled("")
|
||||
assert "terminal" in disabled
|
||||
|
||||
|
||||
class TestClassifyRuntime:
|
||||
"""Verify _classify_runtime correctly classifies runtimes as cloud or local.
|
||||
|
||||
Covers the bug fixed in #628: missing cloud model prefixes for deepseek,
|
||||
cohere, mistral, meta-llama, databricks, and together.
|
||||
"""
|
||||
|
||||
# ── URL-based classification ──────────────────────────────────────────
|
||||
|
||||
def test_localhost_url_is_local(self):
|
||||
assert _classify_runtime(base_url="http://localhost:11434/v1") == "local"
|
||||
|
||||
def test_127_loopback_is_local(self):
|
||||
assert _classify_runtime(base_url="http://127.0.0.1:8080/v1") == "local"
|
||||
|
||||
def test_rfc1918_is_local(self):
|
||||
assert _classify_runtime(base_url="http://192.168.1.10:11434/v1") == "local"
|
||||
|
||||
def test_openrouter_url_is_cloud(self):
|
||||
assert _classify_runtime(base_url="https://openrouter.ai/api/v1") == "cloud"
|
||||
|
||||
def test_anthropic_url_is_cloud(self):
|
||||
assert _classify_runtime(base_url="https://api.anthropic.com") == "cloud"
|
||||
|
||||
def test_deepseek_url_is_cloud(self):
|
||||
assert _classify_runtime(base_url="https://api.deepseek.com/v1") == "cloud"
|
||||
|
||||
# ── Provider-name classification ──────────────────────────────────────
|
||||
|
||||
def test_ollama_provider_is_local(self):
|
||||
assert _classify_runtime(provider="ollama") == "local"
|
||||
|
||||
def test_custom_provider_is_local(self):
|
||||
assert _classify_runtime(provider="custom") == "local"
|
||||
|
||||
def test_openrouter_provider_is_cloud(self):
|
||||
assert _classify_runtime(provider="openrouter") == "cloud"
|
||||
|
||||
def test_nous_provider_is_cloud(self):
|
||||
assert _classify_runtime(provider="nous") == "cloud"
|
||||
|
||||
def test_anthropic_provider_is_cloud(self):
|
||||
assert _classify_runtime(provider="anthropic") == "cloud"
|
||||
|
||||
# ── Previously-missing cloud prefixes (issue #628) ────────────────────
|
||||
|
||||
def test_deepseek_model_prefix_is_cloud(self):
|
||||
assert _classify_runtime(model="deepseek/deepseek-v2") == "cloud"
|
||||
|
||||
def test_cohere_model_prefix_is_cloud(self):
|
||||
assert _classify_runtime(model="cohere/command-r-plus") == "cloud"
|
||||
|
||||
def test_mistralai_model_prefix_is_cloud(self):
|
||||
assert _classify_runtime(model="mistralai/mistral-large-2407") == "cloud"
|
||||
|
||||
def test_meta_llama_model_prefix_is_cloud(self):
|
||||
assert _classify_runtime(model="meta-llama/llama-3.1-70b-instruct") == "cloud"
|
||||
|
||||
def test_databricks_model_prefix_is_cloud(self):
|
||||
assert _classify_runtime(model="databricks/dbrx-instruct") == "cloud"
|
||||
|
||||
def test_together_model_prefix_is_cloud(self):
|
||||
assert _classify_runtime(model="together/together-api-model") == "cloud"
|
||||
|
||||
# ── Providers that were already detected before #628 ─────────────────
|
||||
|
||||
def test_openai_model_prefix_is_cloud(self):
|
||||
assert _classify_runtime(model="openai/gpt-4.1") == "cloud"
|
||||
|
||||
def test_anthropic_model_prefix_is_cloud(self):
|
||||
assert _classify_runtime(model="anthropic/claude-opus-4.6") == "cloud"
|
||||
|
||||
def test_google_model_prefix_is_cloud(self):
|
||||
assert _classify_runtime(model="google/gemini-3-pro") == "cloud"
|
||||
|
||||
def test_minimax_model_prefix_is_cloud(self):
|
||||
assert _classify_runtime(model="minimax/minimax-m2.7") == "cloud"
|
||||
|
||||
# ── Fallback / edge cases ────────────────────────────────────────────
|
||||
|
||||
def test_no_args_defaults_to_cloud(self):
|
||||
assert _classify_runtime() == "cloud"
|
||||
|
||||
def test_empty_strings_default_to_cloud(self):
|
||||
assert _classify_runtime(model="", base_url="", provider="") == "cloud"
|
||||
|
||||
def test_url_takes_priority_over_provider(self):
|
||||
# Explicit local URL wins even if provider looks like cloud
|
||||
assert _classify_runtime(model="openai/gpt-4", base_url="http://localhost:11434/v1", provider="openai") == "local"
|
||||
|
||||
def test_bare_model_name_without_slash_defaults_to_cloud(self):
|
||||
# No slash → can't infer vendor → cloud (safe default)
|
||||
assert _classify_runtime(model="gpt-4o") == "cloud"
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
"""Memory backend tool. Local default, Honcho opt-in."""
|
||||
import json
|
||||
from tools.registry import registry
|
||||
def memory_backend(action, uid="default", key=None, value=None, query=None, meta=None):
|
||||
from agent.memory import get_backend, evaluate
|
||||
b = get_backend()
|
||||
if action=="info": return json.dumps({"ok":True,"backend":b.name,"cloud":b.cloud,"available":b.ok()})
|
||||
if action=="store":
|
||||
if not key or value is None: return json.dumps({"ok":False,"error":"key+value required"})
|
||||
return json.dumps({"ok":b.put(uid,key,value,meta),"key":key})
|
||||
if action=="get":
|
||||
if not key: return json.dumps({"ok":False,"error":"key required"})
|
||||
e=b.get(uid,key)
|
||||
return json.dumps({"ok":True,"key":e.key,"value":e.value,"type":e.etype}) if e else json.dumps({"ok":False,"error":"not found"})
|
||||
if action=="query":
|
||||
if not query: return json.dumps({"ok":False,"error":"query required"})
|
||||
r=b.find(uid,query); return json.dumps({"ok":True,"results":[{"key":e.key,"value":e.value} for e in r],"count":len(r)})
|
||||
if action=="list":
|
||||
r=b.all(uid); return json.dumps({"ok":True,"entries":[{"key":e.key,"type":e.etype} for e in r],"count":len(r)})
|
||||
if action=="delete":
|
||||
if not key: return json.dumps({"ok":False,"error":"key required"})
|
||||
return json.dumps({"ok":b.rm(uid,key)})
|
||||
if action=="evaluate": return json.dumps({"ok":True,**evaluate()})
|
||||
return json.dumps({"ok":False,"error":f"unknown: {action}"})
|
||||
registry.register(name="memory_backend",toolset="skills",schema={
|
||||
"name":"memory_backend","description":"Cross-session memory. Local SQLite default, Honcho cloud opt-in.",
|
||||
"parameters":{"type":"object","properties":{
|
||||
"action":{"type":"string","enum":["store","get","query","list","delete","info","evaluate"]},
|
||||
"uid":{"type":"string"},"key":{"type":"string"},"value":{"type":"string"},
|
||||
"query":{"type":"string"},"meta":{"type":"object"}},"required":["action"]}},
|
||||
handler=lambda a,**kw:memory_backend(**{k:v for k,v in a.items() if v is not None}),emoji="🧠")
|
||||
Reference in New Issue
Block a user