openliate 0.1.0__py3-none-any.whl

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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,6 @@
+openliate/__init__.py,sha256=PCX3pUhkf4NvXWy61ntmDA2sxiF4m4Sd-yIpyo-MLAY,298
+openliate/client.py,sha256=XnhX9GTpcKFHwtG8DxxK-JyXzLCEbeZTljZI1g2vZjQ,4676
+openliate/om.py,sha256=auhEJIJQuoMUI2Ehx8YdIlDAkmS7emmGvmwzbUm-7oU,3952
+openliate-0.1.0.dist-info/METADATA,sha256=5GckY4UhIhVPcPLUve41D0D6Q49j-Uapy7EgNN5tSKc,2469
+openliate-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+openliate-0.1.0.dist-info/RECORD,,

openliate-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any