@simbimbo/memory-ocmemog 0.1.11 → 0.1.13

package/ocmemog/runtime/__init__.py

@@ -0,0 +1,18 @@
+"""ocmemog-native runtime namespace with explicit local module ownership."""
+
+from __future__ import annotations
+
+from . import config, inference, instrumentation, identity, model_roles, model_router, providers, roles, state_store, storage_paths
+
+__all__ = [
+    "config",
+    "identity",
+    "inference",
+    "instrumentation",
+    "model_roles",
+    "model_router",
+    "providers",
+    "roles",
+    "state_store",
+    "storage_paths",
+]

package/ocmemog/runtime/_compat_bridge.py

@@ -0,0 +1,28 @@
+"""Internal helpers for explicitly wrapping legacy `brain.runtime` modules."""
+
+from __future__ import annotations
+
+import importlib
+import sys
+import types
+from types import ModuleType
+
+
+def wrap_legacy_module(alias: str, legacy_name: str) -> ModuleType:
+    """Return a module object exposing `legacy_name` under `alias`.
+
+    This keeps import semantics stable (`import ocmemog.runtime.xxx`) while preserving
+    a native module identity for ocmemog surfaces.
+    """
+
+    legacy = importlib.import_module(legacy_name)
+    module = types.ModuleType(alias)
+    module.__dict__.update(legacy.__dict__)
+    module.__dict__["__name__"] = alias
+    module.__dict__["__package__"] = alias.rpartition(".")[0]
+    module.__dict__["__wrapped_from__"] = legacy_name
+    module.__dict__["__wrapped_module__"] = legacy
+    module.__dict__["__wrapped_by__"] = "ocmemog-runtime-bridge"
+    sys.modules[alias] = module
+    return module
+

package/ocmemog/runtime/config.py

@@ -0,0 +1,34 @@
+"""Runtime configuration surface owned by ocmemog."""
+
+from __future__ import annotations
+
+import os
+
+
+OCMEMOG_EMBED_MODEL_LOCAL = os.environ.get("OCMEMOG_EMBED_MODEL_LOCAL", "")
+OCMEMOG_EMBED_LOCAL_MODEL = OCMEMOG_EMBED_MODEL_LOCAL or os.environ.get("BRAIN_EMBED_MODEL_LOCAL", "simple")
+BRAIN_EMBED_MODEL_LOCAL = OCMEMOG_EMBED_LOCAL_MODEL
+OCMEMOG_EMBED_MODEL_PROVIDER = os.environ.get("OCMEMOG_EMBED_MODEL_PROVIDER", "")
+OCMEMOG_EMBED_PROVIDER = OCMEMOG_EMBED_MODEL_PROVIDER or os.environ.get("BRAIN_EMBED_MODEL_PROVIDER", "")
+BRAIN_EMBED_MODEL_PROVIDER = OCMEMOG_EMBED_PROVIDER
+
+OCMEMOG_MEMORY_MODEL = os.environ.get("OCMEMOG_MEMORY_MODEL", "gpt-4o-mini")
+OCMEMOG_OPENAI_API_BASE = os.environ.get("OCMEMOG_OPENAI_API_BASE", "https://api.openai.com/v1")
+OCMEMOG_OPENAI_EMBED_MODEL = os.environ.get("OCMEMOG_OPENAI_EMBED_MODEL", "text-embedding-3-small")
+
+OCMEMOG_LOCAL_LLM_BASE_URL = os.environ.get("OCMEMOG_LOCAL_LLM_BASE_URL", "http://127.0.0.1:18080/v1")
+OCMEMOG_LOCAL_LLM_MODEL = os.environ.get("OCMEMOG_LOCAL_LLM_MODEL", "qwen2.5-7b-instruct")
+OCMEMOG_LOCAL_EMBED_BASE_URL = os.environ.get("OCMEMOG_LOCAL_EMBED_BASE_URL", "http://127.0.0.1:18081/v1")
+OCMEMOG_LOCAL_EMBED_MODEL = os.environ.get("OCMEMOG_LOCAL_EMBED_MODEL", "nomic-embed-text-v1.5")
+
+OCMEMOG_OLLAMA_HOST = os.environ.get("OCMEMOG_OLLAMA_HOST", "http://127.0.0.1:11434")
+OCMEMOG_OLLAMA_MODEL = os.environ.get("OCMEMOG_OLLAMA_MODEL", "qwen2.5:7b")
+OCMEMOG_OLLAMA_EMBED_MODEL = os.environ.get("OCMEMOG_OLLAMA_EMBED_MODEL", "nomic-embed-text:latest")
+
+OCMEMOG_PROMOTION_THRESHOLD = float(os.environ.get("OCMEMOG_PROMOTION_THRESHOLD", "0.5"))
+OCMEMOG_DEMOTION_THRESHOLD = float(os.environ.get("OCMEMOG_DEMOTION_THRESHOLD", "0.2"))
+
+OCMEMOG_PONDER_ENABLED = os.environ.get("OCMEMOG_PONDER_ENABLED", "true")
+OCMEMOG_PONDER_MODEL = os.environ.get("OCMEMOG_PONDER_MODEL", OCMEMOG_MEMORY_MODEL)
+OCMEMOG_LESSON_MINING_ENABLED = os.environ.get("OCMEMOG_LESSON_MINING_ENABLED", "true")
+

package/ocmemog/runtime/identity.py

@@ -0,0 +1,115 @@
+"""Runtime identity and capability ownership metadata for ocmemog runtime surfaces."""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from typing import Any, Dict, List
+
+from importlib import import_module
+
+
+ENGINE_ID = "ocmemog-native"
+SURFACE_ENGINE_OWNER = "ocmemog-native"
+SURFACE_COMPAT_OWNER = "brain-runtime-shim"
+SURFACE_MISSING = "missing"
+
+# Ordered list keeps output stable for deterministic status payloads.
+_RUNTIME_SURFACES = (
+    "ocmemog.runtime.roles",
+    "ocmemog.runtime.identity",
+    "ocmemog.runtime.config",
+    "ocmemog.runtime.inference",
+    "ocmemog.runtime.model_router",
+    "ocmemog.runtime.model_roles",
+    "ocmemog.runtime.providers",
+    "ocmemog.runtime.state_store",
+    "ocmemog.runtime.storage_paths",
+)
+
+_SURFACE_DETAILS = {
+    "ocmemog.runtime.roles": "Native role registry for context/priority metadata",
+    "ocmemog.runtime.identity": "Identity and capability ownership manifest",
+    "ocmemog.runtime.config": "Configuration surface for memory/model providers",
+    "ocmemog.runtime.inference": "Inference orchestration helper",
+    "ocmemog.runtime.model_router": "Model routing helper",
+    "ocmemog.runtime.model_roles": "Model-role mapping helper",
+    "ocmemog.runtime.providers": "Provider execution surface for embeddings",
+    "ocmemog.runtime.state_store": "Runtime state persistence surface",
+    "ocmemog.runtime.storage_paths": "Storage path helpers",
+}
+
+
+def _surface_owner(module_name: str) -> tuple[str, str, str]:
+    """Return (owner, provider_module, status) for an import target."""
+
+    try:
+        module = import_module(module_name)
+    except Exception as exc:  # pragma: no cover - defensive surface.
+        return (SURFACE_MISSING, "<import-failed>", f"{type(exc).__name__}: {exc}")
+
+    wrapped_from = getattr(module, "__wrapped_from__", None)
+    wrapped_by = getattr(module, "__wrapped_by__", None)
+
+    provider_module = module.__name__
+    owner = SURFACE_ENGINE_OWNER
+
+    if isinstance(wrapped_from, str) and wrapped_from.strip():
+        owner = SURFACE_COMPAT_OWNER
+        provider_module = wrapped_from.strip()
+    elif isinstance(wrapped_by, str) and wrapped_by.strip():
+        owner = SURFACE_COMPAT_OWNER
+    elif not provider_module.startswith("ocmemog."):
+        owner = SURFACE_COMPAT_OWNER
+
+    return (owner, provider_module, "ok")
+
+
+def get_capability_ownership() -> List[Dict[str, Any]]:
+    """Return a stable capability ownership matrix for runtime surfaces."""
+
+    owned: List[Dict[str, Any]] = []
+    for surface in _RUNTIME_SURFACES:
+        owner, provider_module, status = _surface_owner(surface)
+        owned.append(
+            {
+                "surface": surface,
+                "provider_module": provider_module,
+                "owner": owner,
+                "status": "ready" if owner != SURFACE_MISSING else "missing",
+                "status_detail": status,
+                "description": _SURFACE_DETAILS.get(surface, "runtime surface"),
+            }
+        )
+    return owned
+
+
+def get_runtime_identity() -> Dict[str, Any]:
+    """Return a compact runtime-identity payload."""
+
+    capabilities = get_capability_ownership()
+    grouped = OrderedDict([
+        (SURFACE_ENGINE_OWNER, []),
+        (SURFACE_COMPAT_OWNER, []),
+        (SURFACE_MISSING, []),
+    ])
+    for item in capabilities:
+        grouped.setdefault(item["owner"], []).append(item["surface"])
+
+    return {
+        "engine": ENGINE_ID,
+        "schema": "ocmemog-runtime-identity-v1",
+        "capabilities": capabilities,
+        "capability_counts": {
+            SURFACE_ENGINE_OWNER: len(grouped[SURFACE_ENGINE_OWNER]),
+            SURFACE_COMPAT_OWNER: len(grouped[SURFACE_COMPAT_OWNER]),
+            SURFACE_MISSING: len(grouped[SURFACE_MISSING]),
+        },
+        "surface_names": list(_RUNTIME_SURFACES),
+    }
+
+
+__all__ = [
+    "ENGINE_ID",
+    "get_capability_ownership",
+    "get_runtime_identity",
+]

package/ocmemog/runtime/inference.py

@@ -0,0 +1,163 @@
+"""LLM inference helpers owned by ocmemog."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import urllib.request
+
+from . import config, instrumentation, state_store
+
+
+LOGFILE = state_store.report_log_path()
+
+
+def _infer_openai_compatible(
+    prompt: str,
+    *,
+    base_url: str,
+    model: str,
+    api_key: str | None = None,
+    provider_label: str = "openai-compatible",
+) -> dict[str, str]:
+    url = f"{base_url.rstrip('/')}/chat/completions"
+    payload = {
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.2,
+    }
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(url, data=data, method="POST")
+    if api_key:
+        req.add_header("Authorization", f"Bearer {api_key}")
+    req.add_header("Content-Type", "application/json")
+
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            response = json.loads(resp.read().decode("utf-8"))
+    except Exception as exc:
+        instrumentation.emit_event(LOGFILE, "brain_infer_error", status="error", provider=provider_label, error=str(exc))
+        return {"status": "error", "error": f"request_failed:{exc}"}
+
+    try:
+        output = response["choices"][0]["message"]["content"]
+    except Exception as exc:
+        instrumentation.emit_event(LOGFILE, "brain_infer_error", status="error", provider=provider_label, error=str(exc))
+        return {"status": "error", "error": "invalid_response"}
+
+    return {"status": "ok", "output": str(output).strip()}
+
+
+def _infer_ollama(prompt: str, model: str | None = None) -> dict[str, str]:
+    payload = {
+        "model": model or config.OCMEMOG_OLLAMA_MODEL,
+        "prompt": prompt,
+        "stream": False,
+    }
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(f"{config.OCMEMOG_OLLAMA_HOST.rstrip('/')}/api/generate", data=data, method="POST")
+    req.add_header("Content-Type", "application/json")
+    try:
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            response = json.loads(resp.read().decode("utf-8"))
+    except Exception as exc:
+        instrumentation.emit_event(LOGFILE, "brain_infer_error", status="error", provider="ollama", error=str(exc))
+        return {"status": "error", "error": f"ollama_failed:{exc}"}
+    output = response.get("response")
+    if not output:
+        instrumentation.emit_event(LOGFILE, "brain_infer_error", status="error", provider="ollama", error="invalid_response")
+        return {"status": "error", "error": "invalid_response"}
+    return {"status": "ok", "output": str(output).strip()}
+
+
+def _looks_like_local_openai_model(name: str) -> bool:
+    if not name:
+        return False
+    lowered = name.strip().lower()
+    return lowered.startswith("local-openai:") or lowered.startswith("local_openai:") or lowered.startswith("llamacpp:")
+
+
+def _normalize_local_model_name(name: str) -> str:
+    lowered = (name or "").strip()
+    for prefix in ("local-openai:", "local_openai:", "llamacpp:"):
+        if lowered.lower().startswith(prefix):
+            return lowered[len(prefix):]
+    return lowered
+
+
+def _looks_like_ollama_model(name: str) -> bool:
+    if not name:
+        return False
+    lowered = name.strip().lower()
+    if lowered.startswith("ollama:"):
+        return True
+    if "/" in lowered:
+        return False
+    return ":" in lowered
+
+
+def stats() -> dict[str, object]:
+    materialized_local = int(_LOCAL_INFER_STATS.get("local_success", 0)) + int(_LOCAL_INFER_STATS.get("cache_hits", 0))
+    est_prompt_tokens_saved = materialized_local * _AVG_PROMPT_TOKENS_SAVED
+    est_completion_tokens_saved = materialized_local * _AVG_COMPLETION_TOKENS_SAVED
+    est_cost_saved = (
+        (est_prompt_tokens_saved / 1000.0) * _EST_FRONTIER_INPUT_COST_PER_1K
+        + (est_completion_tokens_saved / 1000.0) * _EST_FRONTIER_OUTPUT_COST_PER_1K
+    )
+    return {
+        "cache_entries": len(_LOCAL_INFER_CACHE),
+        "warm_models": sorted(_MODEL_WARM_STATE.keys()),
+        "frontier_calls_avoided_est": materialized_local,
+        "prompt_tokens_saved_est": est_prompt_tokens_saved,
+        "completion_tokens_saved_est": est_completion_tokens_saved,
+        "cost_saved_usd_est": round(est_cost_saved, 4),
+        **{k: int(v) for k, v in _LOCAL_INFER_STATS.items()},
+    }
+
+
+def infer(prompt: str, provider_name: str | None = None) -> dict[str, str]:
+    if not isinstance(prompt, str) or not prompt.strip():
+        return {"status": "error", "error": "empty_prompt"}
+
+    use_ollama = os.environ.get("OCMEMOG_USE_OLLAMA", "").lower() in {"1", "true", "yes"}
+    model_override = provider_name or config.OCMEMOG_MEMORY_MODEL
+    if _looks_like_local_openai_model(model_override):
+        model = _normalize_local_model_name(model_override) or config.OCMEMOG_LOCAL_LLM_MODEL
+        return _infer_openai_compatible(
+            prompt,
+            base_url=config.OCMEMOG_LOCAL_LLM_BASE_URL,
+            model=model,
+            api_key=os.environ.get("OCMEMOG_LOCAL_LLM_API_KEY") or os.environ.get("LOCAL_LLM_API_KEY"),
+            provider_label="local-openai",
+        )
+    if use_ollama or _looks_like_ollama_model(model_override):
+        model = model_override.split(":", 1)[-1] if model_override.startswith("ollama:") else model_override
+        return _infer_ollama(prompt, model)
+
+    api_key = os.environ.get("OCMEMOG_OPENAI_API_KEY") or os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        return _infer_openai_compatible(
+            prompt,
+            base_url=config.OCMEMOG_LOCAL_LLM_BASE_URL,
+            model=config.OCMEMOG_LOCAL_LLM_MODEL,
+            api_key=os.environ.get("OCMEMOG_LOCAL_LLM_API_KEY") or os.environ.get("LOCAL_LLM_API_KEY"),
+            provider_label="local-openai",
+        )
+
+    model = model_override
+    return _infer_openai_compatible(
+        prompt,
+        base_url=config.OCMEMOG_OPENAI_API_BASE,
+        model=model,
+        api_key=api_key,
+        provider_label="openai",
+    )
+
+
+def parse_operator_name(text: str) -> dict[str, str] | None:
+    match = re.search(r"\bmy name is ([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b", text, flags=re.IGNORECASE)
+    if not match:
+        return None
+    return {"name": match.group(1)}
+

package/ocmemog/runtime/instrumentation.py

@@ -0,0 +1,20 @@
+"""Event emission utility for runtime instrumentation."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def emit_event(path: Path, event: str, **fields: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "event": event,
+        **fields,
+    }
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(payload, sort_keys=True) + "\n")
+

package/ocmemog/runtime/memory/__init__.py

@@ -0,0 +1,91 @@
+"""ocmemog-native memory namespace with native surfaces."""
+
+from __future__ import annotations
+
+import importlib
+
+# Native-first memory surfaces (core path has no package-level wrapper bootstrapping).
+from . import (
+    api,
+    candidate,
+    memory_consolidation,
+    distill,
+    embedding_engine,
+    health,
+    integrity,
+    memory_taxonomy,
+    memory_links,
+    provenance,
+    promote,
+    retrieval,
+    store,
+    unresolved_state,
+    vector_index,
+)
+
+_NATIVE_MEMORY_SURFACES = (
+    "api",
+    "candidate",
+    "distill",
+    "embedding_engine",
+    "health",
+    "integrity",
+    "memory_consolidation",
+    "memory_taxonomy",
+    "memory_links",
+    "provenance",
+    "promote",
+    "retrieval",
+    "store",
+    "unresolved_state",
+    "vector_index",
+)
+
+_MEMORY_SURFACES = (
+    "conversation_state",
+    "memory_synthesis",
+    "pondering_engine",
+    "reinforcement",
+    "semantic_search",
+    "memory_salience",
+    "freshness",
+)
+
+
+def __getattr__(name: str):
+    if name in _NATIVE_MEMORY_SURFACES:
+        return globals()[name]
+    if name in _MEMORY_SURFACES:
+        module = importlib.import_module(f"{__name__}.{name}")
+        globals()[name] = module
+        return module
+    raise AttributeError(name)
+
+
+__all__ = [
+    "api",
+    "candidate",
+    "conversation_state",
+    "distill",
+    "embedding_engine",
+    "health",
+    "integrity",
+    "memory_links",
+    "memory_consolidation",
+    "memory_taxonomy",
+    "memory_synthesis",
+    "promote",
+    "provenance",
+    "pondering_engine",
+    "freshness",
+    "memory_salience",
+    "reinforcement",
+    "retrieval",
+    "semantic_search",
+    "store",
+    "unresolved_state",
+    "vector_index",
+]
+
+# No legacy-shimmed memory surfaces remain in this namespace.
+__legacy_memory_surfaces__ = ()