admeasy 0.1.0__tar.gz

admeasy-0.1.0/.gitignore

@@ -0,0 +1,19 @@
+# Python
+.venv/
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+build/
+dist/
+
+# Node
+node_modules/
+typescript/dist/
+typescript/build/
+*.tgz
+
+# Never commit credentials
+.admeasy/credentials
+.env
+.env.*

admeasy-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.5
+Name: admeasy
+Version: 0.1.0
+Summary: Python SDK and CLI for Admeasy AI, the AI employee infrastructure platform.
+Author-email: Admeasy <aadesh.panwar@admeasy.in>
+License: TBD
+Keywords: admeasy,agents,ai-employees,cli,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.25
+Requires-Dist: pydantic<3,>=2.4
+Requires-Dist: typer>=0.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# admeasy (Python)
+
+Python SDK and CLI for **Admeasy AI**, the AI employee infrastructure platform.
+
+The SDK is a client of the Admeasy control plane. Employees you create here
+are the same records the Admeasy website shows. Nothing is stored locally
+except your API key in `~/.admeasy/credentials`, written by `admeasy login`.
+
+```bash
+pip install admeasy
+export ADMEASY_API_KEY="..."       # the key from the Admeasy website Integrations page
+admeasy whoami
+admeasy employee list
+```
+
+```python
+from admeasy import Agent, Client, EmployeeLimitReachedError
+
+client = Client()                  # reads ADMEASY_API_KEY / ADMEASY_API_URL
+print(client.get_workspace(), client.get_limits())
+
+try:
+    agent = Agent.create("sales-agent", model="sarvam", description="Follow up on new leads")
+except EmployeeLimitReachedError as exc:
+    print(f"Plan is full: {exc.current}/{exc.limit}")
+```
+
+Sarvam is the preferred currently available model, and `sarvam` is the default.
+
+Release 0.1 is synchronous (`httpx.Client`). See the repository README and
+`docs/API_CONTRACT.md` for the full contract, and `docs/BACKEND_GAPS.md` for
+the backend changes the SDK still depends on.
+
+## Development
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e '.[dev]'
+pytest
+```

admeasy-0.1.0/README.md

@@ -0,0 +1,40 @@
+# admeasy (Python)
+
+Python SDK and CLI for **Admeasy AI**, the AI employee infrastructure platform.
+
+The SDK is a client of the Admeasy control plane. Employees you create here
+are the same records the Admeasy website shows. Nothing is stored locally
+except your API key in `~/.admeasy/credentials`, written by `admeasy login`.
+
+```bash
+pip install admeasy
+export ADMEASY_API_KEY="..."       # the key from the Admeasy website Integrations page
+admeasy whoami
+admeasy employee list
+```
+
+```python
+from admeasy import Agent, Client, EmployeeLimitReachedError
+
+client = Client()                  # reads ADMEASY_API_KEY / ADMEASY_API_URL
+print(client.get_workspace(), client.get_limits())
+
+try:
+    agent = Agent.create("sales-agent", model="sarvam", description="Follow up on new leads")
+except EmployeeLimitReachedError as exc:
+    print(f"Plan is full: {exc.current}/{exc.limit}")
+```
+
+Sarvam is the preferred currently available model, and `sarvam` is the default.
+
+Release 0.1 is synchronous (`httpx.Client`). See the repository README and
+`docs/API_CONTRACT.md` for the full contract, and `docs/BACKEND_GAPS.md` for
+the backend changes the SDK still depends on.
+
+## Development
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e '.[dev]'
+pytest
+```

admeasy-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "admeasy"
+version = "0.1.0"
+description = "Python SDK and CLI for Admeasy AI, the AI employee infrastructure platform."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "TBD" }
+authors = [{ name = "Admeasy", email = "aadesh.panwar@admeasy.in" }]
+keywords = ["admeasy", "ai-employees", "agents", "sdk", "cli"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+]
+dependencies = [
+  "httpx>=0.25,<1",
+  "pydantic>=2.4,<3",
+  "typer>=0.9",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=7.4",
+  "respx>=0.21",
+]
+
+[project.scripts]
+admeasy = "admeasy.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/admeasy"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+  "integration: opt-in tests against a real Admeasy test backend; skipped unless ADMEASY_TEST_API_URL and ADMEASY_TEST_API_KEY are set",
+]

admeasy-0.1.0/src/admeasy/__init__.py

@@ -0,0 +1,64 @@
+"""Admeasy AI — Python SDK for the AI employee infrastructure platform.
+
+One Admeasy account, one source of truth (the Admeasy control plane), many
+interfaces. This package is a client of the same employee records the
+Admeasy website uses; it never keeps a second database.
+"""
+
+__version__ = "0.1.0"
+
+from .agent import Agent  # noqa: E402
+from .client import ROUTES, Client, Limits, Model, Route, User, Workspace  # noqa: E402
+from .config import DEFAULT_API_URL, DEFAULT_MODEL  # noqa: E402
+from .connections import Connection  # noqa: E402
+from .employees import Employee  # noqa: E402
+from .errors import (  # noqa: E402
+    AdmeasyAuthenticationError,
+    AdmeasyError,
+    APIConnectionError,
+    AuthenticationError,
+    ConfigurationError,
+    ConflictError,
+    ConnectionNotAvailableError,
+    EmployeeLimitReachedError,
+    MissingAPIKeyError,
+    NotFoundError,
+    PaymentRequiredError,
+    PermissionDeniedError,
+    PlanLimitError,
+    RateLimitError,
+    ServerError,
+    ValidationError,
+)
+
+__all__ = [
+    "__version__",
+    "Agent",
+    "Client",
+    "Connection",
+    "Employee",
+    "Limits",
+    "Model",
+    "Route",
+    "ROUTES",
+    "User",
+    "Workspace",
+    "DEFAULT_API_URL",
+    "DEFAULT_MODEL",
+    "AdmeasyError",
+    "AdmeasyAuthenticationError",
+    "AuthenticationError",
+    "MissingAPIKeyError",
+    "ConfigurationError",
+    "PermissionDeniedError",
+    "NotFoundError",
+    "ValidationError",
+    "ConflictError",
+    "PaymentRequiredError",
+    "PlanLimitError",
+    "EmployeeLimitReachedError",
+    "RateLimitError",
+    "ServerError",
+    "APIConnectionError",
+    "ConnectionNotAvailableError",
+]

admeasy-0.1.0/src/admeasy/agent.py

@@ -0,0 +1,184 @@
+"""``Agent`` — a handle to one persistent Admeasy AI employee.
+
+An ``Agent`` is never a local-only object. ``Agent.create`` asks the control
+plane to create the employee (the website sees it immediately), ``Agent.get``
+loads an existing one, and ``update``/``delete``/``connect`` all call the
+server. Quota is enforced server-side; the SDK only surfaces
+``EmployeeLimitReachedError``.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from .client import Client
+from .config import DEFAULT_MODEL
+from .connections import Connection
+from .employees import Employee
+from .errors import ConfigurationError, ConnectionNotAvailableError, NotFoundError
+
+
+class Agent:
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        *,
+        model: str = DEFAULT_MODEL,
+        description: Optional[str] = None,
+        client: Optional[Client] = None,
+        employee: Optional[Employee] = None,
+    ) -> None:
+        """Build a handle. ``Agent(name=...)`` alone does NOT create anything;
+        call ``Agent.create(...)``, ``Agent.get(id)`` or ``agent.resolve()``."""
+        self._client = client or Client()
+        self._employee = employee
+        self._name = name if employee is None else employee.name
+        self._model = model if employee is None else (employee.model or model)
+        self._description = description if employee is None else employee.description
+
+    # -- constructors --------------------------------------------------------
+    @classmethod
+    def create(
+        cls,
+        name: str,
+        *,
+        model: str = DEFAULT_MODEL,
+        description: Optional[str] = None,
+        instructions: Optional[str] = None,
+        connections: Optional[List[str]] = None,
+        department: Optional[str] = None,
+        schedule: Optional[str] = None,
+        client: Optional[Client] = None,
+        workspace_id: Optional[str] = None,
+    ) -> "Agent":
+        client = client or Client()
+        employee = client.create_employee(
+            name=name,
+            model=model,
+            description=description,
+            instructions=instructions,
+            connections=connections,
+            department=department,
+            schedule=schedule,
+            workspace_id=workspace_id,
+        )
+        return cls(client=client, employee=employee, model=model)
+
+    @classmethod
+    def get(cls, employee_id: str, *, client: Optional[Client] = None, workspace_id: Optional[str] = None) -> "Agent":
+        client = client or Client()
+        return cls(client=client, employee=client.get_employee(employee_id, workspace_id=workspace_id))
+
+    @classmethod
+    def list(cls, *, client: Optional[Client] = None, workspace_id: Optional[str] = None) -> List["Agent"]:
+        client = client or Client()
+        return [cls(client=client, employee=e) for e in client.list_employees(workspace_id=workspace_id)]
+
+    def resolve(self) -> "Agent":
+        """Bind this handle to the existing employee with the same name.
+        Never creates a duplicate; raises NotFoundError if none exists."""
+        if self._employee is not None:
+            return self
+        if not self._name:
+            raise ConfigurationError("Agent has no name or id to resolve")
+        found = self._client.employees.find(self._name)
+        if not found:
+            raise NotFoundError(
+                f"No Admeasy employee named {self._name!r} in this workspace. "
+                f"Use Agent.create({self._name!r}, model={self._model!r}) to create it.",
+                code="EMPLOYEE_NOT_FOUND",
+            )
+        self._employee = found
+        return self
+
+    # -- properties ----------------------------------------------------------
+    def _require(self) -> Employee:
+        if self._employee is None:
+            raise ConfigurationError(
+                "This Agent is not bound to an Admeasy employee yet. "
+                "Use Agent.create(...), Agent.get(id) or agent.resolve()."
+            )
+        return self._employee
+
+    @property
+    def employee(self) -> Optional[Employee]:
+        return self._employee
+
+    @property
+    def id(self) -> Optional[str]:
+        return self._employee.id if self._employee else None
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._employee.name if self._employee else self._name
+
+    @property
+    def status(self) -> Optional[str]:
+        return self._employee.status if self._employee else None
+
+    @property
+    def model(self) -> Optional[str]:
+        return (self._employee.model if self._employee else None) or self._model
+
+    @property
+    def workspace(self) -> Optional[str]:
+        if self._employee and self._employee.workspace_id:
+            return self._employee.workspace_id
+        return self._client.workspace_id
+
+    @property
+    def connections(self) -> List[str]:
+        return list(self._employee.connections) if self._employee else []
+
+    def __repr__(self) -> str:
+        return f"Agent(id={self.id!r}, name={self.name!r}, status={self.status!r}, model={self.model!r})"
+
+    # -- server operations ---------------------------------------------------
+    def refresh(self) -> "Agent":
+        emp = self._require()
+        self._employee = self._client.get_employee(emp.id, workspace_id=emp.workspace_id)
+        return self
+
+    def update(self, **fields: Any) -> "Agent":
+        emp = self._require()
+        self._employee = self._client.update_employee(emp.id, workspace_id=emp.workspace_id, **fields)
+        return self
+
+    def delete(self) -> Dict[str, Any]:
+        emp = self._require()
+        result = self._client.delete_employee(emp.id, workspace_id=emp.workspace_id)
+        self._employee = None
+        return result
+
+    def connect(self, name: str) -> Connection:
+        """Attach a workspace connection to this employee.
+
+        Generic: the SDK asks the control plane which connections exist for
+        the workspace. If ``name`` is not connected there, it raises
+        ``ConnectionNotAvailableError`` with instructions instead of guessing.
+        """
+        emp = self._require()
+        connections = self._client.list_connections(workspace_id=emp.workspace_id)
+        match = next((c for c in connections if c.matches(name)), None)
+        if match is None or not match.connected:
+            connected = sorted(c.id for c in connections if c.connected)
+            state = "is not connected" if match else "is not available"
+            raise ConnectionNotAvailableError(
+                f"Connection {name!r} {state} in workspace {emp.workspace_id}. "
+                "Authorize it in the Admeasy website (Integrations page) with an account that "
+                "can grant access, then retry. Currently connected: "
+                + (", ".join(connected) if connected else "none")
+                + ".",
+                code="CONNECTION_NOT_AVAILABLE",
+            )
+        if match.id not in emp.connections:
+            self._employee = self._client.update_employee(
+                emp.id, workspace_id=emp.workspace_id, connections=[*emp.connections, match.id]
+            )
+        return match
+
+    async def run(self, task: str) -> Any:  # pragma: no cover - Release 0.2
+        raise NotImplementedError(
+            "agent.run() arrives with the Admeasy runtime (Release 0.2). "
+            "Release 0.1 covers auth, employee CRUD, quota and sync."
+        )