dsh-biocore 0.5.1 → 0.5.4

package/lib/index.js

@@ -385,7 +385,17 @@ function coreConfigPayload(dataDir) {
   try { switches = readSwitches(dataDir).switches } catch { switches = {} }
   let persona = ''
   try { persona = readPersonaText(dataDir) } catch { persona = '' }
+  // Keys this host does not own (summarizer, recall, anything the core or a
+  // human added) must survive a re-configure. Dropping them made capture raise
+  // "no summarizer block" and memory vanished silently behind an adapter
+  // fallback, so carry the previous file forward and overwrite only our keys.
+  let carried = {}
+  try {
+    const previous = JSON.parse(readFileSync(join(dataDir, 'core_config.json'), 'utf8'))
+    if (previous && typeof previous === 'object' && !Array.isArray(previous)) carried = previous
+  } catch { carried = {} }
   return {
+    ...carried,
     data_dir: dataDir,
     persona_text: persona,
     embedding: config.embedding,

package/lib/py/bridge.py

@@ -256,12 +256,90 @@ def _json_arg(value):
         return {}
 
 
+_SUMMARIZER_STORE = [""]
+
+
+def _deepseek_key():
+    """API key for the summariser: env first, then the DSH credential store."""
+    key = str(os.environ.get("DEEPSEEK_API_KEY") or "").strip()
+    if key:
+        return key
+    try:
+        import re
+        text = open(str(_DSH_HOME / ".credentials.yaml"), encoding="utf-8").read()
+        hit = re.search(r"DEEPSEEK_API_KEY:\s*(\S+)", text)
+        if hit:
+            return hit.group(1).strip().strip('"').strip("'")
+    except Exception:
+        pass
+    return ""
+
+
+def _summarizer_config(store):
+    """The summariser block of the store's core_config.json (no silent default)."""
+    for name in ("core_config.json", "config.json"):
+        path = os.path.join(str(store or ""), name)
+        if not os.path.isfile(path):
+            continue
+        try:
+            data = json.loads(open(path, encoding="utf-8").read())
+        except Exception:
+            continue
+        block = data.get("summarizer") if isinstance(data, dict) else None
+        if isinstance(block, dict) and str(block.get("model") or "").strip():
+            return {"base_url": str(block.get("base_url") or block.get("baseUrl")
+                                    or "https://api.deepseek.com/v1"),
+                    "model": str(block["model"]).strip(),
+                    "key": str(block.get("key") or block.get("api_key") or "").strip()}
+    raise RuntimeError("summarizer config missing: core_config.json has no summarizer block "
+                       "(the event layer cannot close events without it)")
+
+
+def _llm_summarizer(prompt):
+    """Event-close summariser for the real plugin path.
+
+    capture() only closes events when it is handed a summariser; without one the
+    event layer buffers forever and no event ever exists (the production path had
+    exactly that hole). This uses the host's own model over HTTPS.
+    """
+    cfg = _summarizer_config(_SUMMARIZER_STORE[0])
+    key = cfg["key"] or _deepseek_key()
+    if not key:
+        raise RuntimeError("summarizer config has no key and DEEPSEEK_API_KEY is unset")
+    import urllib.request
+    model = cfg["model"]
+    base = cfg["base_url"]
+    body = json.dumps({
+        "model": model,
+        "temperature": 0,
+        "messages": [{"role": "system", "content": "只输出 JSON 对象，不要解释。"},
+                     {"role": "user", "content": str(prompt)}],
+    }).encode("utf-8")
+    req = urllib.request.Request(base.rstrip("/") + "/chat/completions", data=body,
+                                 headers={"Content-Type": "application/json",
+                                          "Authorization": "Bearer " + key})
+    try:
+        with urllib.request.urlopen(req, timeout=120) as resp:
+            data = json.loads(resp.read().decode("utf-8", "replace"))
+        return str((data.get("choices") or [{}])[0].get("message", {}).get("content") or "")
+    except Exception as exc:
+        sys.stderr.write("__bioSummarizer failed: %s\n" % str(exc)[:160])
+        return None
+
+
 def _memory_capture(argv):
     store = argv[1]
     session_id = argv[2]
     role = argv[3] if len(argv) > 3 else "user"
     text = argv[4] if len(argv) > 4 else ""
     config = _json_arg(argv[5] if len(argv) > 5 else "")
+    config = dict(config) if isinstance(config, dict) else {}
+    _SUMMARIZER_STORE[0] = str(store or "")
+    if not config.get("event_summarizer"):
+        # the host never supplied one; without it no event is ever generated.
+        # _llm_summarizer raises when core_config.json has no summarizer block.
+        _summarizer_config(store)
+        config["event_summarizer"] = _llm_summarizer
     result = _pipeline().capture(session_id, role, text, store, config)
     decision = result.get("decision") if isinstance(result, dict) else {}
     decision = decision if isinstance(decision, dict) else {}
@@ -276,6 +354,10 @@ def _memory_capture(argv):
 
 
 def _memory_inject(argv):
+    return _memory_inject_impl(argv)
+
+
+def _memory_inject_impl(argv):
     store = argv[1]
     session_id = argv[2]
     kwargs = {}
@@ -313,9 +395,25 @@ def _runtime_gate(argv):
     return _emit(_pipeline().gate_reply(reply, payload))
 
 
+_EVENT_ACTIONS = ("memory_capture", "memory_inject")
+
+
 def _runtime_action(argv):
     action = argv[1] if len(argv) > 1 else ""
     payload = _json_arg(argv[2] if len(argv) > 2 else "")
+    if action in _EVENT_ACTIONS and isinstance(payload, dict):
+        # the real node path calls dispatch(); it must carry the summariser too,
+        # or the event layer stays silently off (capture) / raises (render)
+        payload = dict(payload)
+        store = str(payload.get("store") or payload.get("root") or "")
+        _SUMMARIZER_STORE[0] = store
+        if str(os.environ.get("BIOCORE_STRICT_TS") or "") == "1" \
+                and action == "memory_capture" and not payload.get("now"):
+            raise RuntimeError("capture payload has no logical timestamp (now); "
+                               "BIOCORE_STRICT_TS forbids falling back to the wall clock")
+        if not payload.get("event_summarizer"):
+            _summarizer_config(store)
+            payload["event_summarizer"] = _llm_summarizer
     return _emit(_pipeline().dispatch(action, payload))
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-biocore",
-  "version": "0.5.1",
+  "version": "0.5.4",
   "type": "module",
   "description": "BioCore DSH UI: per-session state tab, standalone instrument panel, /api/biocore/state, session/event one_turn updates, /bio sync.",
   "main": "lib/index.js",

package/python/biocore_memory/adapters/dsh_cli.py

@@ -50,7 +50,15 @@ def dispatch(engine, action, **kwargs):
     if action == "recall":
         return engine.recall(kwargs.get("query", ""),
                              budget=kwargs.get("budget", 3),
-                             vector=kwargs.get("vector"))
+                             vector=kwargs.get("vector"),
+                             mode=kwargs.get("mode", "now"))
+    if action in ("spatial_rank", "rank"):
+        from ..core.config import SPATIAL_SELECT_DEPTH
+        return engine.spatial_rank(
+            kwargs.get("query", ""),
+            query_ts=kwargs.get("query_ts"),
+            limit=kwargs.get("limit", SPATIAL_SELECT_DEPTH),
+            scope=kwargs.get("scope", "default"))
     if action == "forget":
         return engine.forget(kwargs.get("entry_id", ""))
     if action == "pin":
@@ -130,10 +138,27 @@ def cmd_recall(args):
                     "tier": "expand" if score >= 0.55 else "hint",
                     "role": entry.get("role"), "ts": entry.get("ts")})
     return _emit({"ok": True, "command": "recall", "query": args.query,
+                  "mode": getattr(args, "mode", "now") or "now",
+                  "spatial_select": getattr(engine, "_last_spatial_select", None),
                   "count": len(out), "results": out,
                   "hint": "no_cue" if not out else ""})
 
 
+def cmd_rank(args):
+    """Whole-store spatial selection (engine.spatial_rank), JSON out."""
+    engine = _engine_class()(data_dir=args.store)
+    try:
+        limit = int(args.limit) if args.limit is not None else None
+    except Exception:
+        limit = None
+    scope = str(getattr(args, "scope", "") or "").strip() or None
+    payload = engine.spatial_rank(args.query,
+                                  query_ts=getattr(args, "ts", None),
+                                  limit=limit, scope=scope)
+    return _emit({"ok": bool(payload.get("ok")), "command": "rank",
+                  "result": payload})
+
+
 def cmd_forget(args):
     engine = _engine_class()(data_dir=args.store)
     result = engine.forget(args.entry_id)
@@ -233,6 +258,20 @@ def cmd_export(args):
     return _emit({"ok": True, "command": "export", "payload": payload})
 
 
+def cmd_reembed(args):
+    """Rebuild every vector in the store with the configured provider.
+
+    The supported way out of an embedding-space mismatch: the store is read
+    through the runtime pipeline (sqlite primary), every entry is re-embedded,
+    event centroids are re-derived and the meta is re-stamped.
+    """
+    from biocore_runtime import pipeline as P
+    session = str(getattr(args, "session", "") or "default")
+    result = P.reembed_store(args.store, session,
+                            batch_size=int(getattr(args, "batch_size", 0) or 32))
+    return _emit(dict(result, command="reembed"))
+
+
 def cmd_stats(args):
     engine = _engine_class()(data_dir=args.store)
     return _emit({"ok": True, "command": "stats", "monitor": engine.monitor()})
@@ -285,8 +324,17 @@ def build_parser():
     r = sp.add_parser("recall", help="query memories")
     r.add_argument("query")
     r.add_argument("--limit", type=int, default=3)
-    r.add_argument("--mode", default="now", choices=("now", "then"))
+    r.add_argument("--mode", default="now", choices=("now", "then", "spatial"))
     r.set_defaults(func=cmd_recall)
+    r = sp.add_parser("rank",
+                      help="top-N over the whole store by five-axis distance")
+    r.add_argument("query")
+    r.add_argument("--limit", type=int, default=None)
+    r.add_argument("--ts", type=float, default=None,
+                   help="anchor the time axis at this epoch (default now)")
+    r.add_argument("--scope", default="",
+                   help="scope filter (default: every scope in the store)")
+    r.set_defaults(func=cmd_rank)
     r = sp.add_parser("forget", help="delete by id")
     r.add_argument("entry_id")
     r.set_defaults(func=cmd_forget)
@@ -319,6 +367,12 @@ def build_parser():
     r.set_defaults(func=cmd_snapshot)
     r = sp.add_parser("consolidate-run", help="run gated consolidation")
     r.set_defaults(func=cmd_consolidate_run)
+    r = sp.add_parser("reembed",
+                      help="rebuild vectors after changing the embedding model/dim")
+    r.add_argument("--store", required=True)
+    r.add_argument("--session", default="default")
+    r.add_argument("--batch-size", dest="batch_size", type=int, default=32)
+    r.set_defaults(func=cmd_reembed)
     return p