openliate 0.1.0__tar.gz

openliate-0.1.0/.gitignore

@@ -0,0 +1,55 @@
+# Dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+.npmrc
+
+# Build outputs
+dist/
+bin/
+pkg/
+build/
+out/
+*.exe
+*.wasm
+*.tsbuildinfo
+
+# Runtime Agent Sessions & State
+sessions/
+.openliate/
+
+# Python artifacts
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.pytest_cache/
+
+# Fern docs local cache
+.fern/
+
+# Logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+bun.lockb
+pnpm-debug.log*
+
+# OS Files
+.DS_Store
+Thumbs.db
+.neon
+
+# Scratch & Local Probing Scripts
+scripts/test-*
+scripts/probe-*
+scripts/inspect-*
+scripts/create-*
+*.local.*

openliate-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.5
+Name: openliate
+Version: 0.1.0
+Summary: Open Source Backend Layer for AI Agents — Built for Sovereign AI Agents From India to the World
+Project-URL: Homepage, https://openliate.tech
+Project-URL: Repository, https://github.com/openliate/openliate
+Project-URL: Documentation, https://docs.openliate.tech
+Project-URL: Issues, https://github.com/openliate/openliate/issues
+Author-email: OpenLiate <vinod@openliate.tech>, Vinod Hatti <gitdevinod@gmail.com>
+License: MIT
+Keywords: agent,aum,autonomous-agents,liate,mcp,om,sarvamai,sovereign-ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT 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 :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24.0
+Description-Content-Type: text/markdown
+
+# OpenLiate — Python SDK
+
+### Sovereign AI Agents in 5 Lines: Class is an Agent.
+`L[LM] · I[ntegration] · A[gent] · T[ools] · E[nvironment]`
+
+---
+
+## Installation
+
+```bash
+pip install openliate
+```
+
+---
+
+## Quickstart (`agent.py`)
+
+```python
+from openliate import liate
+
+class HelloAgent(liate):
+    L = "sarvam/sarvam-105b"
+    I = {"memory": "sessions/hello-agent"}
+    A = {"name": "hello_agent", "intent": "Autonomous Assistant"}
+    T = ["fetch"]
+    E = {"SARVAM_API_KEY": "$SARVAM_API_KEY"}
+
+agent = HelloAgent()
+
+# 1. Inspect declarative AUM manifest
+print(agent.to_manifest())
+
+# 2. Run agent via OpenLiate engine
+result = agent.run("Namaste world!")
+print(result.response)
+```
+
+---
+
+## Architecture: AUM & OM
+
+Every agent declares the 5 orthogonal layers according to the **Agent Unified Manifest (AUM)** standard:
+
+- **`L` (Model):** Sovereign LLM provider and model (e.g., Sarvam 105B).
+- **`I` (Integration):** Memory retention, Postgres, and knowledge repositories.
+- **`A` (Agent / Harness):** Agent name, intent, and reasoning loop.
+- **`T` (Tools):** Anthropic Model Context Protocol (MCP) and custom tools.
+- **`E` (Environment):** Secrets and guardrails.
+
+Execution is powered by the **Orchestration Module (OM)** connecting locally or to deployed cloud endpoints.
+
+---
+
+## License
+
+MIT © [OpenLiate](https://openliate.tech)
+

openliate-0.1.0/README.md

@@ -0,0 +1,57 @@
+# OpenLiate — Python SDK
+
+### Sovereign AI Agents in 5 Lines: Class is an Agent.
+`L[LM] · I[ntegration] · A[gent] · T[ools] · E[nvironment]`
+
+---
+
+## Installation
+
+```bash
+pip install openliate
+```
+
+---
+
+## Quickstart (`agent.py`)
+
+```python
+from openliate import liate
+
+class HelloAgent(liate):
+    L = "sarvam/sarvam-105b"
+    I = {"memory": "sessions/hello-agent"}
+    A = {"name": "hello_agent", "intent": "Autonomous Assistant"}
+    T = ["fetch"]
+    E = {"SARVAM_API_KEY": "$SARVAM_API_KEY"}
+
+agent = HelloAgent()
+
+# 1. Inspect declarative AUM manifest
+print(agent.to_manifest())
+
+# 2. Run agent via OpenLiate engine
+result = agent.run("Namaste world!")
+print(result.response)
+```
+
+---
+
+## Architecture: AUM & OM
+
+Every agent declares the 5 orthogonal layers according to the **Agent Unified Manifest (AUM)** standard:
+
+- **`L` (Model):** Sovereign LLM provider and model (e.g., Sarvam 105B).
+- **`I` (Integration):** Memory retention, Postgres, and knowledge repositories.
+- **`A` (Agent / Harness):** Agent name, intent, and reasoning loop.
+- **`T` (Tools):** Anthropic Model Context Protocol (MCP) and custom tools.
+- **`E` (Environment):** Secrets and guardrails.
+
+Execution is powered by the **Orchestration Module (OM)** connecting locally or to deployed cloud endpoints.
+
+---
+
+## License
+
+MIT © [OpenLiate](https://openliate.tech)
+

openliate-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "openliate"
+version = "0.1.0"
+description = "Open Source Backend Layer for AI Agents — Built for Sovereign AI Agents From India to the World"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+    { name = "OpenLiate", email = "vinod@openliate.tech" },
+    { name = "Vinod Hatti", email = "gitdevinod@gmail.com" }
+]
+keywords = ["liate", "agent", "autonomous-agents", "sovereign-ai", "mcp", "sarvamai", "aum", "om"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT 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 :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "httpx>=0.24.0",
+]
+
+[project.urls]
+Homepage = "https://openliate.tech"
+Repository = "https://github.com/openliate/openliate"
+Documentation = "https://docs.openliate.tech"
+Issues = "https://github.com/openliate/openliate/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/openliate"]
+

openliate-0.1.0/src/openliate/__init__.py

@@ -0,0 +1,10 @@
+"""
+OpenLiate Python SDK — Built for Sovereign AI Agents From India to the World
+Class is an Agent: 1 Class = 5 Properties (L · I · A · T · E)
+"""
+from .om import liate
+from .client import LapiClient, AgentRunResult
+
+__version__ = "0.1.0"
+__all__ = ["liate", "LapiClient", "AgentRunResult"]
+

openliate-0.1.0/src/openliate/client.py

@@ -0,0 +1,127 @@
+"""
+OpenLiate Python LAPI Client
+Connects to OpenLiate Orchestration Module (OM) via standard LAPI /run protocol.
+"""
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+import json
+import urllib.request
+import urllib.error
+import time
+
+@dataclass
+class AgentRunResult:
+    """
+    Standard OpenLiate execution response object.
+    """
+    response: str
+    steps: List[Dict[str, Any]] = field(default_factory=list)
+    execution_time_ms: float = 0.0
+    session_id: Optional[str] = None
+    agent: Optional[str] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+    def __str__(self) -> str:
+        return self.response
+
+class LapiClient:
+    """
+    HTTP client for communicating with OpenLiate LAPI endpoint.
+    Supports both standard library urllib (zero dependencies) and httpx (async).
+    """
+    def __init__(self, endpoint: str = "http://localhost:7071"):
+        self.endpoint = endpoint.rstrip("/")
+
+    def run(self, manifest: Dict[str, Any], prompt: str, session_id: Optional[str] = None) -> AgentRunResult:
+        """
+        Synchronous run via standard urllib.
+        """
+        url = f"{self.endpoint}/run"
+        payload = {
+            "manifest": manifest,
+            "prompt": prompt
+        }
+        if session_id:
+            payload["sessionId"] = session_id
+
+        data = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(
+            url,
+            data=data,
+            headers={"Content-Type": "application/json"}
+        )
+
+        start_time = time.time()
+        try:
+            with urllib.request.urlopen(req, timeout=120) as resp:
+                status = resp.status
+                body = json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            err_body = e.read().decode("utf-8")
+            try:
+                err_json = json.loads(err_body)
+                err_msg = err_json.get("error", err_body)
+            except Exception:
+                err_msg = err_body
+            raise RuntimeError(f"[OpenLiate LAPI Error HTTP {e.code}]: {err_msg}") from e
+        except urllib.error.URLError as e:
+            raise ConnectionError(
+                f"[OpenLiate Connection Error]: Unable to reach LAPI engine at {self.endpoint}. "
+                f"Ensure the OpenLiate engine is running (e.g. `openliate serve` or deployed URL)."
+            ) from e
+
+        duration_ms = (time.time() - start_time) * 1000.0
+
+        return AgentRunResult(
+            response=body.get("text", body.get("response", body.get("output", ""))),
+            steps=body.get("steps", []),
+            execution_time_ms=body.get("latencyMs", body.get("executionTimeMs", duration_ms)),
+            session_id=body.get("sessionId", session_id),
+            agent=body.get("agent", manifest.get("A", {}).get("name", "agent")),
+            raw=body
+        )
+
+    async def arun(self, manifest: Dict[str, Any], prompt: str, session_id: Optional[str] = None) -> AgentRunResult:
+        """
+        Asynchronous run via httpx.
+        """
+        try:
+            import httpx
+        except ImportError:
+            raise ImportError(
+                "httpx is required for asynchronous arun(). Install with: pip install httpx"
+            )
+
+        url = f"{self.endpoint}/run"
+        payload = {
+            "manifest": manifest,
+            "prompt": prompt
+        }
+        if session_id:
+            payload["sessionId"] = session_id
+
+        start_time = time.time()
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            try:
+                resp = await client.post(url, json=payload)
+                resp.raise_for_status()
+                body = resp.json()
+            except httpx.HTTPStatusError as e:
+                raise RuntimeError(f"[OpenLiate LAPI Error HTTP {e.response.status_code}]: {e.response.text}") from e
+            except httpx.RequestError as e:
+                raise ConnectionError(
+                    f"[OpenLiate Connection Error]: Unable to reach LAPI engine at {self.endpoint}. "
+                    f"Ensure OpenLiate is running (`openliate serve` or cloud endpoint)."
+                ) from e
+
+        duration_ms = (time.time() - start_time) * 1000.0
+
+        return AgentRunResult(
+            response=body.get("text", body.get("response", body.get("output", ""))),
+            steps=body.get("steps", []),
+            execution_time_ms=body.get("latencyMs", body.get("executionTimeMs", duration_ms)),
+            session_id=body.get("sessionId", session_id),
+            agent=body.get("agent", manifest.get("A", {}).get("name", "agent")),
+            raw=body
+        )
+

openliate-0.1.0/src/openliate/om.py

@@ -0,0 +1,102 @@
+"""
+Core Engine: OM (Orchestration Module)
+Matches AUM (Agent Unified Manifest) specification across 5 orthogonal layers:
+L[LM] · I[ntegration] · A[gent] · T[ools] · E[nvironment]
+"""
+from typing import Any, Dict, List, Optional, Union
+import os
+from .client import LapiClient, AgentRunResult
+
+class liate:
+    """
+    OM (Orchestration Module) — Python OOP Base Class for AI Agents.
+    Supports pure LIATE authoring across 3 styles:
+    1. Shorthand: L · I · A · T · E
+    2. Full Name: LLM · Integration · Agent · Tools · Environment
+    3. Lowercase: llm · integration · agent · tools · environment
+
+    Example:
+    ```python
+    from openliate import liate
+
+    class HelloAgent(liate):
+        LLM = "sarvam/sarvam-105b"
+        Integration = {"memory": "sessions/hello-agent"}
+        Agent = {"name": "hello_agent"}
+        Tools = ["fetch"]
+        Environment = {"SARVAM_API_KEY": "$SARVAM_API_KEY"}
+
+    agent = HelloAgent()
+    result = agent.run("Namaste world!")
+    print(result)
+    ```
+    """
+    # 1. Shorthand
+    L: Optional[Union[str, Dict[str, Any]]] = None
+    I: Optional[Dict[str, Any]] = None
+    A: Optional[Union[str, Dict[str, Any]]] = None
+    T: Optional[List[Any]] = None
+    E: Optional[Dict[str, str]] = None
+
+    # 2. Full Name
+    LLM: Optional[Union[str, Dict[str, Any]]] = None
+    Integration: Optional[Dict[str, Any]] = None
+    Agent: Optional[Union[str, Dict[str, Any]]] = None
+    Tools: Optional[List[Any]] = None
+    Environment: Optional[Dict[str, str]] = None
+
+    # 3. Lowercase
+    llm: Optional[Union[str, Dict[str, Any]]] = None
+    integration: Optional[Dict[str, Any]] = None
+    agent: Optional[Union[str, Dict[str, Any]]] = None
+    tools: Optional[List[Any]] = None
+    environment: Optional[Dict[str, str]] = None
+
+    def __init__(self, endpoint: Optional[str] = None):
+        self._endpoint = endpoint or os.environ.get("OPENLIATE_ENDPOINT", "http://localhost:7071")
+        self._client = LapiClient(endpoint=self._endpoint)
+
+    def to_manifest(self) -> Dict[str, Any]:
+        """
+        Exports the declarative AUM (Agent Unified Manifest) dictionary.
+        """
+        l_val = self.L if self.L is not None else (self.LLM if self.LLM is not None else self.llm)
+        i_val = self.I if self.I is not None else (self.Integration if self.Integration is not None else self.integration)
+        a_val = self.A if self.A is not None else (self.Agent if self.Agent is not None else self.agent)
+        t_val = self.T if self.T is not None else (self.Tools if self.Tools is not None else self.tools)
+        e_val = self.E if self.E is not None else (self.Environment if self.Environment is not None else self.environment)
+
+        if not l_val:
+            raise ValueError(
+                f"[OpenLiate Error]: Missing required Layer [L] (LLM) in class '{self.__class__.__name__}'. "
+                f"Declare 'L', 'LLM', or 'llm' on your class. "
+                f"OpenLiate never hardcodes or falls back to silent model defaults."
+            )
+
+        name = self.__class__.__name__
+        agent_a = a_val or {"name": name}
+        if isinstance(agent_a, str):
+            agent_a = {"name": agent_a}
+
+        return {
+            "L": l_val,
+            "I": i_val or {},
+            "A": agent_a,
+            "T": t_val or [],
+            "E": e_val or {}
+        }
+
+    def run(self, prompt: str, session_id: Optional[str] = None) -> AgentRunResult:
+        """
+        Executes the agent via OpenLiate LAPI.
+        """
+        manifest = self.to_manifest()
+        return self._client.run(manifest=manifest, prompt=prompt, session_id=session_id)
+
+    async def arun(self, prompt: str, session_id: Optional[str] = None) -> AgentRunResult:
+        """
+        Asynchronously executes the agent via OpenLiate LAPI.
+        """
+        manifest = self.to_manifest()
+        return await self._client.arun(manifest=manifest, prompt=prompt, session_id=session_id)
+

openliate-0.1.0/tests/test_om.py

@@ -0,0 +1,81 @@
+import unittest
+import sys
+import os
+
+# Add src to sys.path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../src")))
+
+from openliate import liate, AgentRunResult
+
+class TestOpenLiatePythonSDK(unittest.TestCase):
+    def test_class_is_an_agent_5_properties(self):
+        class GreetingAgent(liate):
+            L = "sarvam/sarvam-105b"
+            I = {"memory": "sessions/test-python"}
+            A = {"name": "greeting_agent", "intent": "Friendly assistant"}
+            T = ["fetch"]
+            E = {"SARVAM_API_KEY": "test_key_python"}
+
+        agent = GreetingAgent()
+        manifest = agent.to_manifest()
+
+        self.assertEqual(manifest["L"], "sarvam/sarvam-105b")
+        self.assertEqual(manifest["I"], {"memory": "sessions/test-python"})
+        self.assertEqual(manifest["A"]["name"], "greeting_agent")
+        self.assertEqual(manifest["A"]["intent"], "Friendly assistant")
+        self.assertEqual(manifest["T"], ["fetch"])
+        self.assertEqual(manifest["E"]["SARVAM_API_KEY"], "test_key_python")
+
+    def test_strict_layer_l_enforcement(self):
+        class IncompleteAgent(liate):
+            A = {"name": "no_model"}
+
+        agent = IncompleteAgent()
+        with self.assertRaises(ValueError) as ctx:
+            agent.to_manifest()
+        self.assertIn("Missing required Layer [L]", str(ctx.exception))
+
+    def test_full_name_liate_properties(self):
+        class FullNameAgent(liate):
+            LLM = "sarvam/sarvam-105b"
+            Integration = {"memory": "sessions/python-full"}
+            Agent = {"name": "full_python_agent"}
+            Tools = ["fetch"]
+            Environment = {"SARVAM_API_KEY": "py_key"}
+
+        agent = FullNameAgent()
+        manifest = agent.to_manifest()
+        self.assertEqual(manifest["L"], "sarvam/sarvam-105b")
+        self.assertEqual(manifest["I"]["memory"], "sessions/python-full")
+        self.assertEqual(manifest["A"]["name"], "full_python_agent")
+        self.assertEqual(manifest["T"], ["fetch"])
+
+    def test_lowercase_liate_properties(self):
+        class LowercaseAgent(liate):
+            llm = "sarvam/sarvam-105b"
+            integration = {"memory": "sessions/python-lower"}
+            agent = {"name": "lower_python_agent"}
+            tools = ["fetch"]
+            environment = {"SARVAM_API_KEY": "py_key"}
+
+        agent = LowercaseAgent()
+        manifest = agent.to_manifest()
+        self.assertEqual(manifest["L"], "sarvam/sarvam-105b")
+        self.assertEqual(manifest["I"]["memory"], "sessions/python-lower")
+        self.assertEqual(manifest["A"]["name"], "lower_python_agent")
+        self.assertEqual(manifest["T"], ["fetch"])
+
+    def test_agent_run_result_dataclass(self):
+        res = AgentRunResult(
+            response="Hello world",
+            steps=[{"thought": "test"}],
+            execution_time_ms=12.5,
+            session_id="session-123"
+        )
+        self.assertEqual(str(res), "Hello world")
+        self.assertEqual(res.execution_time_ms, 12.5)
+        self.assertEqual(res.session_id, "session-123")
+
+if __name__ == "__main__":
+    unittest.main()
+