lyboai 0.1.0__tar.gz

lyboai-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: lyboai
+Version: 0.1.0
+Summary: LyboAI Mobile Edge Runtime — Python SDK for on-device AI agent creation, evaluation, and training workflows
+Author: LyboAI
+License: Apache-2.0
+Project-URL: Homepage, https://lyboai.app/developers
+Project-URL: Documentation, https://lyboai.app/developers/docs
+Project-URL: Repository, https://github.com/rajandua20/lyboai-mobile-edge-runtime
+Keywords: on-device-ai,edge-ai,llm,slm,agents,offline-ai,private-ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# lyboai (Python SDK)
+
+Python is the **builder's language** for the LyboAI ecosystem: create agents,
+package and sign capability packs, run evaluations, tune routing, and export
+training datasets. Agents execute in the Rust runtime — locally via the
+`lybo` binary (this SDK drives it over the JSON-lines protocol, identical to
+the on-device C ABI) and on phones via the mobile bindings.
+
+```bash
+pip install -e sdk/python        # from the repo, or publish to your index
+cargo build -p lybo-cli           # the runtime the SDK drives
+```
+
+## Create an agent
+
+```python
+from lyboai import Client
+
+with Client(data_dir="/tmp/agent", binary="./target/debug/lybo") as lybo:
+    lybo.install_knowledge(doc_id="handbook", title="Team Handbook",
+                           body="Support tickets are answered within 24 hours.")
+    lybo.register_skill(skill_id="app.ask", name="Ask the handbook",
+                        triggers=["what does the handbook say"],
+                        keywords=["handbook"], pattern="retrieval")
+
+    session = lybo.start_session()
+    out = lybo.run_to_completion(session, "what does the handbook say about tickets")
+    print(out["output"]["text"], out["output"]["sources"])
+```
+
+## Train routing from labelled examples
+
+```python
+from lyboai import train_triggers
+
+learned = train_triggers({
+    "faq.ask":  ["what does the guide say about refunds", "search the faq"],
+    "task.plan": ["plan my week", "break this goal into steps"],
+})
+# → per-skill {"triggers": [...], "keywords": [...]} via class-discriminative
+#   tf-idf; feeds both the keyword tier and the on-device semantic centroids.
+```
+
+## Build, sign, evaluate, ship a pack
+
+```python
+from lyboai import PackBuilder, sign_pack, evaluate
+
+src = (PackBuilder("acme.faq", "FAQ", "1.0.0", publisher="acme")
+       .add_knowledge("faq", "Store FAQ", "Refunds take five business days.")
+       .add_skill("faq.ask", "Ask FAQ", pattern="retrieval",
+                  triggers=learned["faq.ask"]["triggers"],
+                  keywords=learned["faq.ask"]["keywords"],
+                  knowledge_scopes=["acme.faq"])
+       .add_eval_case("faq.suite", "routes", "what does the guide say about refunds",
+                      expect_skill="faq.ask", expect_contains=["refund"])
+       .save("pack.json"))
+sign_pack("pack.json", SECRET_KEY_HEX, "dist/acme-faq.lybopack")
+
+with Client(data_dir="/tmp/qa", trust=[f"acme:{PUBLIC_KEY_HEX}"]) as lybo:
+    lybo.install_pack_file("dist/acme-faq.lybopack")
+    report = evaluate(lybo, suite)          # routing + outcome + content checks
+    assert report.ok, report.summary()      # gate your CI on this
+```
+
+## Export training data (privacy-preserving)
+
+```python
+from lyboai import export_routing_dataset
+export_routing_dataset(lybo, "routing.jsonl")
+# skill ids, confidence, outcomes, latency, model ids — never raw user content.
+```
+
+Run the SDK's own tests: `LYBO_BIN=./target/debug/lybo python3 -m unittest discover sdk/python/tests`

lyboai-0.1.0/README.md

@@ -0,0 +1,74 @@
+# lyboai (Python SDK)
+
+Python is the **builder's language** for the LyboAI ecosystem: create agents,
+package and sign capability packs, run evaluations, tune routing, and export
+training datasets. Agents execute in the Rust runtime — locally via the
+`lybo` binary (this SDK drives it over the JSON-lines protocol, identical to
+the on-device C ABI) and on phones via the mobile bindings.
+
+```bash
+pip install -e sdk/python        # from the repo, or publish to your index
+cargo build -p lybo-cli           # the runtime the SDK drives
+```
+
+## Create an agent
+
+```python
+from lyboai import Client
+
+with Client(data_dir="/tmp/agent", binary="./target/debug/lybo") as lybo:
+    lybo.install_knowledge(doc_id="handbook", title="Team Handbook",
+                           body="Support tickets are answered within 24 hours.")
+    lybo.register_skill(skill_id="app.ask", name="Ask the handbook",
+                        triggers=["what does the handbook say"],
+                        keywords=["handbook"], pattern="retrieval")
+
+    session = lybo.start_session()
+    out = lybo.run_to_completion(session, "what does the handbook say about tickets")
+    print(out["output"]["text"], out["output"]["sources"])
+```
+
+## Train routing from labelled examples
+
+```python
+from lyboai import train_triggers
+
+learned = train_triggers({
+    "faq.ask":  ["what does the guide say about refunds", "search the faq"],
+    "task.plan": ["plan my week", "break this goal into steps"],
+})
+# → per-skill {"triggers": [...], "keywords": [...]} via class-discriminative
+#   tf-idf; feeds both the keyword tier and the on-device semantic centroids.
+```
+
+## Build, sign, evaluate, ship a pack
+
+```python
+from lyboai import PackBuilder, sign_pack, evaluate
+
+src = (PackBuilder("acme.faq", "FAQ", "1.0.0", publisher="acme")
+       .add_knowledge("faq", "Store FAQ", "Refunds take five business days.")
+       .add_skill("faq.ask", "Ask FAQ", pattern="retrieval",
+                  triggers=learned["faq.ask"]["triggers"],
+                  keywords=learned["faq.ask"]["keywords"],
+                  knowledge_scopes=["acme.faq"])
+       .add_eval_case("faq.suite", "routes", "what does the guide say about refunds",
+                      expect_skill="faq.ask", expect_contains=["refund"])
+       .save("pack.json"))
+sign_pack("pack.json", SECRET_KEY_HEX, "dist/acme-faq.lybopack")
+
+with Client(data_dir="/tmp/qa", trust=[f"acme:{PUBLIC_KEY_HEX}"]) as lybo:
+    lybo.install_pack_file("dist/acme-faq.lybopack")
+    report = evaluate(lybo, suite)          # routing + outcome + content checks
+    assert report.ok, report.summary()      # gate your CI on this
+```
+
+## Export training data (privacy-preserving)
+
+```python
+from lyboai import export_routing_dataset
+export_routing_dataset(lybo, "routing.jsonl")
+# skill ids, confidence, outcomes, latency, model ids — never raw user content.
+```
+
+Run the SDK's own tests: `LYBO_BIN=./target/debug/lybo python3 -m unittest discover sdk/python/tests`

lyboai-0.1.0/lyboai/__init__.py

@@ -0,0 +1,40 @@
+"""LyboAI Mobile Edge Runtime — Python SDK.
+
+Python is the *builder's* language in the LyboAI ecosystem: you use it to
+create agents (skills, workflows, knowledge), package and sign capability
+packs, run evaluations, and tune routing from labelled examples. The agents
+themselves run inside the Rust runtime — on desktops via the `lybo` binary
+(which this SDK drives over the JSON-lines protocol) and on phones via the
+mobile bindings.
+
+Quick start::
+
+    from lyboai import Client
+
+    with Client(data_dir="/tmp/agent") as lybo:
+        lybo.install_knowledge(doc_id="h", title="Handbook",
+                               body="Tickets are answered within 24 hours.",
+                               scope="app")
+        lybo.register_skill(skill_id="app.ask", name="Ask",
+                            triggers=["what does the handbook say"],
+                            keywords=["handbook"], pattern="retrieval")
+        session = lybo.start_session()
+        out = lybo.submit(session, "what does the handbook say about tickets")
+        print(out["output"]["text"])
+"""
+
+from .client import Client, LyboError
+from .packs import PackBuilder, sign_pack
+from .training import evaluate, export_routing_dataset, train_triggers
+
+__all__ = [
+    "Client",
+    "LyboError",
+    "PackBuilder",
+    "sign_pack",
+    "evaluate",
+    "export_routing_dataset",
+    "train_triggers",
+]
+
+__version__ = "0.1.0"

lyboai-0.1.0/lyboai/client.py

@@ -0,0 +1,195 @@
+"""Protocol client: drives a local `lybo serve` runtime over JSON lines.
+
+The protocol is identical to the C ABI used on devices, so anything built and
+validated here behaves the same inside a mobile app.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from typing import Any, Iterable, Optional
+
+
+class LyboError(RuntimeError):
+    """Raised when the runtime returns ok=false."""
+
+
+class Client:
+    """Synchronous client bound to a spawned `lybo serve` process."""
+
+    def __init__(
+        self,
+        data_dir: str,
+        binary: Optional[str] = None,
+        trust: Optional[Iterable[str]] = None,   # "publisher:pubkeyhex"
+        packs_dir: Optional[str] = None,
+        model_cmd: Optional[str] = None,
+        semantic: bool = True,
+    ) -> None:
+        binary = binary or shutil.which("lybo") or "lybo"
+        args = [binary, "serve", "--data-dir", data_dir]
+        if semantic:
+            args.append("--semantic")
+        for t in trust or []:
+            args += ["--trust", t]
+        if packs_dir:
+            args += ["--packs", packs_dir]
+        if model_cmd:
+            args += ["--model-cmd", model_cmd]
+        self._proc = subprocess.Popen(
+            args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+        )
+
+    # -- protocol core -----------------------------------------------------
+
+    def request(self, cmd: str, **params: Any) -> Any:
+        """Send one protocol request; return `data` or raise LyboError."""
+        payload = {"cmd": cmd, **{k: v for k, v in params.items() if v is not None}}
+        assert self._proc.stdin and self._proc.stdout
+        self._proc.stdin.write(json.dumps(payload) + "\n")
+        self._proc.stdin.flush()
+        line = self._proc.stdout.readline()
+        if not line:
+            raise LyboError("runtime closed the connection")
+        resp = json.loads(line)
+        if not resp.get("ok"):
+            raise LyboError(resp.get("error", {}).get("message", "unknown error"))
+        return resp.get("data")
+
+    # -- sessions ------------------------------------------------------------
+
+    def start_session(self, thread_id: Optional[str] = None) -> str:
+        return self.request("start_session", thread_id=thread_id)["session_id"]
+
+    def submit(self, session_id: str, text: str) -> dict:
+        return self.request("submit_input", session_id=session_id, text=text)
+
+    def resolve_approval(self, approval_id: str, approved: bool) -> dict:
+        return self.request("resolve_approval", approval_id=approval_id, approved=approved)
+
+    def run_to_completion(
+        self,
+        session_id: str,
+        text: str,
+        answers: Optional[list] = None,
+        approve: bool = True,
+        max_hops: int = 8,
+    ) -> dict:
+        """Submit input and automatically satisfy question/approval pauses —
+        the workhorse for evaluation and scripted testing."""
+        answers = list(answers or [])
+        out = self.submit(session_id, text)
+        hops = 0
+        while out.get("state") in ("awaiting_input", "awaiting_approval") and hops < max_hops:
+            hops += 1
+            if out["state"] == "awaiting_input":
+                answer = answers.pop(0) if answers else "unknown"
+                out = self.submit(session_id, str(answer))
+            else:
+                out = self.resolve_approval(out["approval_id"], approve)
+        return out
+
+    # -- events / approvals ----------------------------------------------------
+
+    def poll_events(self, max_events: int = 200) -> list:
+        return self.request("poll_events", max=max_events)
+
+    def pending_approvals(self) -> list:
+        return self.request("pending_approvals")
+
+    # -- registration ------------------------------------------------------------
+
+    def register_skill(
+        self,
+        skill_id: str,
+        name: str,
+        triggers: list,
+        keywords: list,
+        pattern: Optional[str] = None,
+        workflow_id: Optional[str] = None,
+        description: str = "",
+        allowed_tools: Optional[list] = None,
+        confirmation: str = "sensitive",
+        knowledge_scopes: Optional[list] = None,
+        output_schema: Optional[dict] = None,
+    ) -> None:
+        execution = (
+            {"kind": "workflow", "workflow_id": workflow_id}
+            if workflow_id
+            else {"kind": "pattern", "pattern": pattern or "simple_chat"}
+        )
+        self.request(
+            "register_skill",
+            skill={
+                "skill_id": skill_id,
+                "name": name,
+                "description": description,
+                "pack_id": "app",
+                "triggers": triggers,
+                "keywords": keywords,
+                "execution": execution,
+                "allowed_tools": allowed_tools or [],
+                "confirmation": confirmation,
+                "knowledge_scopes": knowledge_scopes or [],
+                "prompt_template": None,
+                "output_schema": output_schema,
+            },
+        )
+
+    def register_workflow(self, workflow: dict) -> None:
+        self.request("register_workflow", workflow=workflow)
+
+    def install_knowledge(self, doc_id: str, title: str, body: str, scope: str = "app",
+                          source: Optional[str] = None) -> int:
+        return self.request(
+            "install_knowledge",
+            document={"doc_id": doc_id, "title": title, "body": body,
+                      "scope": scope, "source": source},
+        )["chunks"]
+
+    # -- packs -----------------------------------------------------------------
+
+    def install_pack(self, pack: dict, bundled_unsigned_ok: bool = False) -> dict:
+        return self.request("install_pack", pack=pack, bundled_unsigned_ok=bundled_unsigned_ok)
+
+    def install_pack_file(self, path: str) -> dict:
+        with open(path, "r", encoding="utf-8") as f:
+            return self.install_pack(json.load(f))
+
+    def list_packs(self) -> list:
+        return self.request("list_packs")
+
+    # -- observability ------------------------------------------------------------
+
+    def recent_traces(self, limit: int = 20) -> list:
+        return self.request("recent_traces", limit=limit)
+
+    def verify_trace_chain(self) -> bool:
+        return bool(self.request("verify_trace_chain")["valid"])
+
+    # -- lifecycle ------------------------------------------------------------------
+
+    def close(self) -> None:
+        try:
+            if self._proc.stdin:
+                self._proc.stdin.write("exit\n")
+                self._proc.stdin.flush()
+        except Exception:
+            pass
+        self._proc.terminate()
+        try:
+            self._proc.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            self._proc.kill()
+
+    def __enter__(self) -> "Client":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()

lyboai-0.1.0/lyboai/packs.py

@@ -0,0 +1,149 @@
+"""Pack authoring: build capability-pack documents in Python and sign them
+with the `lybo` CLI (the secret key never touches this SDK's memory model —
+signing shells out so keys can stay in your vault/CI environment)."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from typing import Any, Optional
+
+
+class PackBuilder:
+    """Fluent builder for `.lybopack` source documents."""
+
+    def __init__(
+        self,
+        pack_id: str,
+        name: str,
+        version: str,
+        publisher: str,
+        description: str = "",
+        min_runtime_version: str = "0.1.0",
+        permissions: Optional[list] = None,
+        observability: str = "local_only",
+    ) -> None:
+        self.doc: dict = {
+            "manifest": {
+                "pack_id": pack_id,
+                "name": name,
+                "version": version,
+                "publisher": publisher,
+                "publisher_key": "",
+                "description": description,
+                "domain": "",
+                "min_runtime_version": min_runtime_version,
+                "platforms": ["ios", "android"],
+                "regions": [],
+                "permissions": permissions or [],
+                "model_requirements": [],
+                "skills": [],
+                "workflows": [],
+                "knowledge_docs": 0,
+                "observability": observability,
+                "content_sha256": "",
+                "rollback_to": None,
+            },
+            "content": {
+                "skills": [],
+                "workflows": [],
+                "knowledge": [],
+                "prompts": [],
+                "policies": [],
+                "eval_suites": [],
+                "ui": None,
+            },
+            "signature": None,
+        }
+
+    # -- content -----------------------------------------------------------
+
+    def add_skill(
+        self,
+        skill_id: str,
+        name: str,
+        triggers: list,
+        keywords: list,
+        pattern: Optional[str] = None,
+        workflow_id: Optional[str] = None,
+        description: str = "",
+        allowed_tools: Optional[list] = None,
+        confirmation: str = "sensitive",
+        knowledge_scopes: Optional[list] = None,
+        output_schema: Optional[dict] = None,
+    ) -> "PackBuilder":
+        execution: dict[str, Any] = (
+            {"kind": "workflow", "workflow_id": workflow_id}
+            if workflow_id
+            else {"kind": "pattern", "pattern": pattern or "simple_chat"}
+        )
+        self.doc["content"]["skills"].append(
+            {
+                "skill_id": skill_id,
+                "name": name,
+                "description": description,
+                "pack_id": "",
+                "triggers": triggers,
+                "keywords": keywords,
+                "execution": execution,
+                "allowed_tools": allowed_tools or [],
+                "confirmation": confirmation,
+                "knowledge_scopes": knowledge_scopes or [],
+                "prompt_template": None,
+                "output_schema": output_schema,
+            }
+        )
+        self.doc["manifest"]["skills"].append(skill_id)
+        return self
+
+    def add_workflow(self, workflow: dict) -> "PackBuilder":
+        workflow.setdefault("pack_id", "")
+        self.doc["content"]["workflows"].append(workflow)
+        self.doc["manifest"]["workflows"].append(workflow["workflow_id"])
+        return self
+
+    def add_knowledge(self, doc_id: str, title: str, body: str,
+                      source: Optional[str] = None) -> "PackBuilder":
+        self.doc["content"]["knowledge"].append(
+            {"doc_id": doc_id, "title": title, "body": body, "scope": "",
+             "source": source, "region": None, "review_by_ms": None, "expires_ms": None}
+        )
+        self.doc["manifest"]["knowledge_docs"] = len(self.doc["content"]["knowledge"])
+        return self
+
+    def add_eval_case(self, suite_id: str, case_id: str, input_text: str,
+                      expect_skill: Optional[str] = None,
+                      expect_contains: Optional[list] = None,
+                      answers: Optional[list] = None) -> "PackBuilder":
+        suites = self.doc["content"]["eval_suites"]
+        suite = next((s for s in suites if s["suite_id"] == suite_id), None)
+        if suite is None:
+            suite = {"suite_id": suite_id,
+                     "pack_id": self.doc["manifest"]["pack_id"], "cases": []}
+            suites.append(suite)
+        case = {"case_id": case_id, "input": input_text,
+                "expect_skill": expect_skill,
+                "expect_contains": expect_contains or [], "expect_schema": None}
+        if answers:
+            case["answers"] = answers  # consumed by lyboai.evaluate, not the core
+        suite["cases"].append(case)
+        return self
+
+    # -- output ------------------------------------------------------------
+
+    def save(self, path: str) -> str:
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(self.doc, f, indent=2, ensure_ascii=False)
+        return path
+
+
+def sign_pack(source_json: str, secret_key_hex: str, out_path: str,
+              lybo_binary: str = "lybo") -> str:
+    """Sign a pack source with the CLI; returns the output path."""
+    result = subprocess.run(
+        [lybo_binary, "sign", source_json, "--key", secret_key_hex, "-o", out_path],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"lybo sign failed: {result.stderr.strip()}")
+    return out_path

lyboai-0.1.0/lyboai/training.py

@@ -0,0 +1,168 @@
+"""Training & evaluation utilities.
+
+“Training” for on-device agents means three concrete, privacy-preserving
+loops, all supported here:
+
+1. **Evaluation-driven iteration** — run labelled cases through the real
+   runtime (routing, workflows, approvals) and measure outcomes before you
+   ship a pack.
+2. **Trigger/keyword tuning** — learn discriminative keywords per skill from
+   labelled utterances, improving both the keyword tier and the semantic
+   centroid tier of the routing cascade (centroids are built from these
+   phrases on-device).
+3. **Dataset export** — turn runtime traces into training corpora (e.g. for
+   distilling a tiny intent classifier). Traces carry routing metadata, not
+   raw user content; your labelled corpus comes from your own eval sets.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import re
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from .client import Client
+
+_STOP = {
+    "the", "a", "an", "and", "or", "to", "of", "in", "on", "for", "with",
+    "is", "are", "was", "be", "this", "that", "it", "my", "me", "i", "you",
+    "please", "can", "could", "would", "do", "does", "about", "at", "by",
+}
+
+
+def _tokens(text: str) -> List[str]:
+    return [t for t in re.split(r"[^a-z0-9]+", text.lower()) if len(t) > 1 and t not in _STOP]
+
+
+# ── 1. Evaluation ─────────────────────────────────────────────────────────
+
+@dataclass
+class CaseResult:
+    case_id: str
+    passed: bool
+    failures: List[str] = field(default_factory=list)
+    routed_skill: Optional[str] = None
+    outcome_state: Optional[str] = None
+
+
+@dataclass
+class EvalReport:
+    total: int
+    passed: int
+    results: List[CaseResult]
+
+    @property
+    def ok(self) -> bool:
+        return self.passed == self.total
+
+    def summary(self) -> str:
+        lines = [f"{self.passed}/{self.total} cases passed"]
+        for r in self.results:
+            mark = "✓" if r.passed else "✗"
+            lines.append(f"  {mark} {r.case_id}" + ("" if r.passed else f" — {'; '.join(r.failures)}"))
+        return "\n".join(lines)
+
+
+def evaluate(client: Client, suite: dict, approve: bool = True) -> EvalReport:
+    """Run an eval suite (same shape packs ship) against a live runtime.
+
+    Checks routing (via the run's trace), completion state, and output
+    substrings. `answers` on a case feed `ask_user` pauses in order.
+    """
+    results: List[CaseResult] = []
+    for case in suite.get("cases", []):
+        session = client.start_session()
+        out = client.run_to_completion(
+            session, case["input"], answers=case.get("answers"), approve=approve
+        )
+        failures: List[str] = []
+
+        traces = client.recent_traces(1)
+        routed = traces[0].get("skill_id") if traces else None
+        expect_skill = case.get("expect_skill")
+        if expect_skill and routed != expect_skill:
+            failures.append(f"routed to {routed!r}, expected {expect_skill!r}")
+
+        state = out.get("state")
+        if state != "completed":
+            failures.append(f"finished in state {state!r}")
+        else:
+            text = json.dumps(out.get("output", {})).lower()
+            for needle in case.get("expect_contains") or []:
+                if needle.lower() not in text:
+                    failures.append(f"output missing {needle!r}")
+
+        results.append(CaseResult(case["case_id"], not failures, failures, routed, state))
+    return EvalReport(len(results), sum(r.passed for r in results), results)
+
+
+# ── 2. Trigger/keyword training ───────────────────────────────────────────
+
+def train_triggers(examples: Dict[str, List[str]], top_keywords: int = 6) -> Dict[str, dict]:
+    """Learn routing triggers from labelled utterances.
+
+    `examples` maps skill_id → list of user phrases. Returns per-skill
+    `{"triggers": [...], "keywords": [...]}` where keywords are chosen by
+    class-discriminative tf-idf (frequent inside the class, rare outside).
+    Feed the result into skill definitions / PackBuilder; both the keyword
+    tier and the on-device semantic centroid tier consume them.
+    """
+    df: Counter = Counter()
+    class_tf: Dict[str, Counter] = defaultdict(Counter)
+    n_classes = max(len(examples), 1)
+
+    for skill_id, phrases in examples.items():
+        seen_in_class = set()
+        for phrase in phrases:
+            for tok in _tokens(phrase):
+                class_tf[skill_id][tok] += 1
+                seen_in_class.add(tok)
+        for tok in seen_in_class:
+            df[tok] += 1
+
+    out: Dict[str, dict] = {}
+    for skill_id, phrases in examples.items():
+        scored = {
+            tok: tf * (math.log((1 + n_classes) / (1 + df[tok])) + 1.0)
+            for tok, tf in class_tf[skill_id].items()
+        }
+        keywords = [t for t, _ in sorted(scored.items(), key=lambda kv: -kv[1])[:top_keywords]]
+        # Triggers: the most representative full phrases (shortest first for
+        # tiny-model friendliness), capped at 6.
+        triggers = sorted(set(phrases), key=len)[:6]
+        out[skill_id] = {"triggers": triggers, "keywords": keywords}
+    return out
+
+
+# ── 3. Dataset export ─────────────────────────────────────────────────────
+
+def export_routing_dataset(client: Client, path: str, limit: int = 200) -> int:
+    """Export routing/outcome metadata from local traces as JSONL.
+
+    Privacy note: traces do not contain raw user content by design — this
+    export carries skill/workflow ids, confidence, outcomes, latency, and
+    model ids, suitable for routing analytics and classifier-distillation
+    pipelines that join against your *own* labelled eval corpora.
+    """
+    rows = 0
+    with open(path, "w", encoding="utf-8") as f:
+        for trace in client.recent_traces(limit):
+            intent_meta = next(
+                (e.get("meta") for e in trace.get("events", [])
+                 if e.get("kind") == "intent_resolved"), {},
+            ) or {}
+            f.write(json.dumps({
+                "trace_id": trace.get("trace_id"),
+                "skill_id": trace.get("skill_id"),
+                "workflow_id": trace.get("workflow_id"),
+                "routing_confidence": intent_meta.get("confidence"),
+                "outcome": trace.get("outcome"),
+                "model_ids": trace.get("model_ids"),
+                "latency_ms": (trace.get("completed_ms") or 0) - trace.get("started_ms", 0),
+                "steps": len(trace.get("events", [])),
+            }) + "\n")
+            rows += 1
+    return rows

lyboai-0.1.0/lyboai.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: lyboai
+Version: 0.1.0
+Summary: LyboAI Mobile Edge Runtime — Python SDK for on-device AI agent creation, evaluation, and training workflows
+Author: LyboAI
+License: Apache-2.0
+Project-URL: Homepage, https://lyboai.app/developers
+Project-URL: Documentation, https://lyboai.app/developers/docs
+Project-URL: Repository, https://github.com/rajandua20/lyboai-mobile-edge-runtime
+Keywords: on-device-ai,edge-ai,llm,slm,agents,offline-ai,private-ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# lyboai (Python SDK)
+
+Python is the **builder's language** for the LyboAI ecosystem: create agents,
+package and sign capability packs, run evaluations, tune routing, and export
+training datasets. Agents execute in the Rust runtime — locally via the
+`lybo` binary (this SDK drives it over the JSON-lines protocol, identical to
+the on-device C ABI) and on phones via the mobile bindings.
+
+```bash
+pip install -e sdk/python        # from the repo, or publish to your index
+cargo build -p lybo-cli           # the runtime the SDK drives
+```
+
+## Create an agent
+
+```python
+from lyboai import Client
+
+with Client(data_dir="/tmp/agent", binary="./target/debug/lybo") as lybo:
+    lybo.install_knowledge(doc_id="handbook", title="Team Handbook",
+                           body="Support tickets are answered within 24 hours.")
+    lybo.register_skill(skill_id="app.ask", name="Ask the handbook",
+                        triggers=["what does the handbook say"],
+                        keywords=["handbook"], pattern="retrieval")
+
+    session = lybo.start_session()
+    out = lybo.run_to_completion(session, "what does the handbook say about tickets")
+    print(out["output"]["text"], out["output"]["sources"])
+```
+
+## Train routing from labelled examples
+
+```python
+from lyboai import train_triggers
+
+learned = train_triggers({
+    "faq.ask":  ["what does the guide say about refunds", "search the faq"],
+    "task.plan": ["plan my week", "break this goal into steps"],
+})
+# → per-skill {"triggers": [...], "keywords": [...]} via class-discriminative
+#   tf-idf; feeds both the keyword tier and the on-device semantic centroids.
+```
+
+## Build, sign, evaluate, ship a pack
+
+```python
+from lyboai import PackBuilder, sign_pack, evaluate
+
+src = (PackBuilder("acme.faq", "FAQ", "1.0.0", publisher="acme")
+       .add_knowledge("faq", "Store FAQ", "Refunds take five business days.")
+       .add_skill("faq.ask", "Ask FAQ", pattern="retrieval",
+                  triggers=learned["faq.ask"]["triggers"],
+                  keywords=learned["faq.ask"]["keywords"],
+                  knowledge_scopes=["acme.faq"])
+       .add_eval_case("faq.suite", "routes", "what does the guide say about refunds",
+                      expect_skill="faq.ask", expect_contains=["refund"])
+       .save("pack.json"))
+sign_pack("pack.json", SECRET_KEY_HEX, "dist/acme-faq.lybopack")
+
+with Client(data_dir="/tmp/qa", trust=[f"acme:{PUBLIC_KEY_HEX}"]) as lybo:
+    lybo.install_pack_file("dist/acme-faq.lybopack")
+    report = evaluate(lybo, suite)          # routing + outcome + content checks
+    assert report.ok, report.summary()      # gate your CI on this
+```
+
+## Export training data (privacy-preserving)
+
+```python
+from lyboai import export_routing_dataset
+export_routing_dataset(lybo, "routing.jsonl")
+# skill ids, confidence, outcomes, latency, model ids — never raw user content.
+```
+
+Run the SDK's own tests: `LYBO_BIN=./target/debug/lybo python3 -m unittest discover sdk/python/tests`

lyboai-0.1.0/lyboai.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+lyboai/__init__.py
+lyboai/client.py
+lyboai/packs.py
+lyboai/training.py
+lyboai.egg-info/PKG-INFO
+lyboai.egg-info/SOURCES.txt
+lyboai.egg-info/dependency_links.txt
+lyboai.egg-info/top_level.txt
+tests/test_sdk.py

lyboai-0.1.0/lyboai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lyboai-0.1.0/lyboai.egg-info/top_level.txt

@@ -0,0 +1 @@
+lyboai

lyboai-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lyboai"
+version = "0.1.0"
+description = "LyboAI Mobile Edge Runtime — Python SDK for on-device AI agent creation, evaluation, and training workflows"
+readme = "README.md"
+license = { text = "Apache-2.0" }
+requires-python = ">=3.9"
+authors = [{ name = "LyboAI" }]
+keywords = ["on-device-ai", "edge-ai", "llm", "slm", "agents", "offline-ai", "private-ai"]
+dependencies = []
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://lyboai.app/developers"
+Documentation = "https://lyboai.app/developers/docs"
+Repository = "https://github.com/rajandua20/lyboai-mobile-edge-runtime"
+
+[tool.setuptools.packages.find]
+include = ["lyboai*"]
+exclude = ["tests*"]

lyboai-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lyboai-0.1.0/tests/test_sdk.py

@@ -0,0 +1,147 @@
+"""Python SDK integration tests against the real Rust runtime.
+
+Run:  LYBO_BIN=/path/to/lybo python3 -m unittest discover sdk/python/tests
+"""
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from lyboai import Client, PackBuilder, evaluate, export_routing_dataset, sign_pack, train_triggers
+
+BIN = os.environ.get("LYBO_BIN", "lybo")
+REPO = os.environ.get("LYBO_REPO", os.path.join(os.path.dirname(__file__), "..", "..", ".."))
+
+
+def new_client(**kw):
+    return Client(data_dir=tempfile.mkdtemp(prefix="lybo-py-"), binary=BIN, **kw)
+
+
+class TestClient(unittest.TestCase):
+    def test_chat_events_and_traces(self):
+        with new_client() as lybo:
+            s = lybo.start_session()
+            out = lybo.submit(s, "hello there")
+            self.assertEqual(out["state"], "completed")
+            kinds = {e["type"] for e in lybo.poll_events(300)}
+            self.assertIn("agent.started", kinds)
+            self.assertIn("agent.completed", kinds)
+            self.assertEqual(len(lybo.recent_traces(5)), 1)
+            self.assertTrue(lybo.verify_trace_chain())
+
+    def test_agent_creation_rag_and_workflow(self):
+        with new_client() as lybo:
+            lybo.install_knowledge(
+                doc_id="handbook", title="Team Handbook",
+                body="Support tickets must be answered within 24 hours. "
+                     "Escalations go to the duty manager.",
+            )
+            lybo.register_skill(
+                skill_id="app.ask", name="Ask handbook",
+                triggers=["what does the handbook say"],
+                keywords=["handbook", "policy"], pattern="retrieval",
+            )
+            lybo.register_workflow({
+                "workflow_id": "wf.note", "version": "1", "pack_id": "app",
+                "description": "", "initial_state": "confirm",
+                "max_steps": 16, "auto_checkpoint": True,
+                "states": {
+                    "confirm": {
+                        "step": {"kind": "confirm",
+                                 "message_template": "Save \"{{input}}\"?"},
+                        "transitions": [
+                            {"when": {"kind": "approved"}, "to": "save"},
+                            {"when": {"kind": "rejected"}, "to": "cancelled"}],
+                    },
+                    "save": {
+                        "step": {"kind": "tool_call", "tool_id": "create_note",
+                                 "args_template": {"title": "Note", "body": "{{input}}"},
+                                 "output_field": "note"},
+                        "transitions": [{"when": {"kind": "tool_ok"}, "to": "done"}],
+                    },
+                    "done": {"step": {"kind": "end",
+                                       "output_template": {"status": "saved", "note": "$note"}},
+                             "transitions": []},
+                    "cancelled": {"step": {"kind": "end",
+                                            "output_template": {"status": "cancelled"}},
+                                  "transitions": []},
+                },
+            })
+            lybo.register_skill(
+                skill_id="app.note", name="Save note",
+                triggers=["save a note"], keywords=["note", "save"],
+                workflow_id="wf.note",
+            )
+
+            s = lybo.start_session()
+            out = lybo.submit(s, "what does the handbook say about tickets")
+            self.assertEqual(out["state"], "completed")
+            self.assertIn("Team Handbook", out["output"]["sources"])
+
+            out = lybo.run_to_completion(s, "save a note: call the supplier tomorrow")
+            self.assertEqual(out["state"], "completed")
+            self.assertEqual(out["output"]["status"], "saved")
+
+    def test_training_utilities(self):
+        learned = train_triggers({
+            "research.ask": ["what does the manual say about pumps",
+                              "search the documents for safety rules",
+                              "look up the maintenance guide"],
+            "task.plan": ["plan my week", "break this goal into steps",
+                           "make a plan for the launch"],
+        })
+        self.assertIn("manual", learned["research.ask"]["keywords"] +
+                                 learned["research.ask"]["triggers"][0].split())
+        self.assertIn("plan", learned["task.plan"]["keywords"])
+        self.assertNotIn("plan", learned["research.ask"]["keywords"])
+
+    def test_pack_build_sign_install_evaluate_export(self):
+        keys = json.loads(subprocess.run(
+            [BIN, "keygen"], capture_output=True, text=True).stdout)
+        learned = train_triggers({
+            "faq.ask": ["what does the guide say about refunds",
+                         "search the faq for shipping times"],
+        })["faq.ask"]
+
+        with tempfile.TemporaryDirectory() as tmp:
+            src = os.path.join(tmp, "pack.json")
+            out_pack = os.path.join(tmp, "faq.lybopack")
+            (PackBuilder("py.faq", "FAQ", "1.0.0", "py-tests",
+                          description="Python-built pack")
+                .add_knowledge("faq", "Store FAQ",
+                               "Refunds are processed within five business days. "
+                               "Shipping takes two days domestically.")
+                .add_skill("faq.ask", "Ask FAQ",
+                           triggers=learned["triggers"], keywords=learned["keywords"],
+                           pattern="retrieval",
+                           knowledge_scopes=["py.faq"])
+                .add_eval_case("faq.suite", "routes", 
+                               "what does the guide say about refunds",
+                               expect_skill="faq.ask", expect_contains=["refund"])
+                .save(src))
+            sign_pack(src, keys["secret_key_hex"], out_pack, lybo_binary=BIN)
+
+            with new_client(trust=[f"py-tests:{keys['public_key_hex']}"]) as lybo:
+                installed = lybo.install_pack_file(out_pack)
+                self.assertEqual(installed["pack_id"], "py.faq")
+
+                with open(src, encoding="utf-8") as f:
+                    suite = json.load(f)["content"]["eval_suites"][0]
+                report = evaluate(lybo, suite)
+                self.assertTrue(report.ok, report.summary())
+
+                ds = os.path.join(tmp, "routing.jsonl")
+                rows = export_routing_dataset(lybo, ds)
+                self.assertGreaterEqual(rows, 1)
+                with open(ds, encoding="utf-8") as fh:
+                    first = json.loads(fh.readline())
+                self.assertEqual(first["skill_id"], "faq.ask")
+                self.assertNotIn("input", first)  # no raw content in exports
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)