aclade 0.1.0__tar.gz

aclade-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: aclade
+Version: 0.1.0
+Summary: Official Python SDK for Aclade — autonomous AI experts that do real work. `import aclade`, delegate a task, read the report.
+Author-email: Aclade <support@aclade.com>
+License: Proprietary (UNLICENSED) — distributed exclusively for users of the Aclade platform
+Project-URL: Homepage, https://aclade.com
+Project-URL: npm (local connector), https://www.npmjs.com/package/aclade
+Keywords: aclade,ai,agent,autonomous,experts,sdk,api
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# aclade
+
+**The official Python SDK for [Aclade](https://aclade.com)** — autonomous AI experts that do real work.
+
+`import aclade` and you can list your AI team, delegate tasks to individual experts, and read their reports — from any Python code, notebook, or pipeline.
+
+## Install
+
+```bash
+pip install aclade
+```
+
+Python 3.8+, zero third-party dependencies (standard library only).
+
+## Get a token
+
+1. Sign in at [aclade.com](https://aclade.com)
+2. **Settings → Local Agent → Get connection token** (the same token the local connector uses)
+3. `export ACLADE_TOKEN=<TOKEN>`
+
+Tokens are signed 12-hour sessions bound to your workspace. If you already connected a machine with the [npm connector](https://www.npmjs.com/package/aclade), the SDK picks the token up from `~/.aclade-agent.json` automatically — `import aclade` just works.
+
+## Quickstart
+
+```python
+import aclade
+
+team = aclade.Aclade()                    # token from $ACLADE_TOKEN or ~/.aclade-agent.json
+team = aclade.Aclade(token="<TOKEN>")     # …or explicitly
+
+# Who's on the roster?
+for e in team.experts():
+    print(e["name"], "—", e["title"])
+
+# Delegate a task and wait for the report
+result = team.delegate("Priya", "Summarize our top 3 customer complaints and draft replies")
+print(result["status"])                   # completed | needs-input | needs-approval
+print(result["run"]["report"])
+```
+
+## The three outcomes
+
+| `result["status"]` | Meaning | What to do |
+|---|---|---|
+| `completed` | The expert finished the work | Read `result["run"]["report"]` |
+| `needs-input` | The expert asked clarifying questions | Re-call with `answers={"<question>": "<answer>"}` |
+| `needs-approval` | A high-risk step awaits a human | Approve in the portal (email link goes to your admin) |
+
+## CLI
+
+```bash
+aclade experts                # roster
+aclade run "Priya" "task"     # delegate + print the report
+aclade tasks                  # pending tasks by expert
+aclade agent                  # local-agent fleet (connector installs)
+aclade whoami                 # identity carried by the token
+```
+
+## Where does the AI run?
+
+On aclade.com — not on your machine. This SDK is the official client: it holds your token, sends work, and returns results. The reasoning harness, tools, and per-second metering are Aclade platform services — the same way `import stripe` never contains Stripe's rails.
+
+Optionally, your machine can also run the [zero-trust local connector](https://www.npmjs.com/package/aclade) (`npm i -g aclade`), which lets your experts act on your own filesystem, shell, and browser — outbound HTTPS polling only, no inbound ports.
+
+## Security notes
+
+- The token is a credential: anyone holding it can delegate work as your workspace (billed to your account). Keep it in an env var or secrets manager.
+- This package ships no AI logic, model weights, or telemetry.
+- License: proprietary (`UNLICENSED`), for users of the Aclade platform.

aclade-0.1.0/README.md

@@ -0,0 +1,69 @@
+# aclade
+
+**The official Python SDK for [Aclade](https://aclade.com)** — autonomous AI experts that do real work.
+
+`import aclade` and you can list your AI team, delegate tasks to individual experts, and read their reports — from any Python code, notebook, or pipeline.
+
+## Install
+
+```bash
+pip install aclade
+```
+
+Python 3.8+, zero third-party dependencies (standard library only).
+
+## Get a token
+
+1. Sign in at [aclade.com](https://aclade.com)
+2. **Settings → Local Agent → Get connection token** (the same token the local connector uses)
+3. `export ACLADE_TOKEN=<TOKEN>`
+
+Tokens are signed 12-hour sessions bound to your workspace. If you already connected a machine with the [npm connector](https://www.npmjs.com/package/aclade), the SDK picks the token up from `~/.aclade-agent.json` automatically — `import aclade` just works.
+
+## Quickstart
+
+```python
+import aclade
+
+team = aclade.Aclade()                    # token from $ACLADE_TOKEN or ~/.aclade-agent.json
+team = aclade.Aclade(token="<TOKEN>")     # …or explicitly
+
+# Who's on the roster?
+for e in team.experts():
+    print(e["name"], "—", e["title"])
+
+# Delegate a task and wait for the report
+result = team.delegate("Priya", "Summarize our top 3 customer complaints and draft replies")
+print(result["status"])                   # completed | needs-input | needs-approval
+print(result["run"]["report"])
+```
+
+## The three outcomes
+
+| `result["status"]` | Meaning | What to do |
+|---|---|---|
+| `completed` | The expert finished the work | Read `result["run"]["report"]` |
+| `needs-input` | The expert asked clarifying questions | Re-call with `answers={"<question>": "<answer>"}` |
+| `needs-approval` | A high-risk step awaits a human | Approve in the portal (email link goes to your admin) |
+
+## CLI
+
+```bash
+aclade experts                # roster
+aclade run "Priya" "task"     # delegate + print the report
+aclade tasks                  # pending tasks by expert
+aclade agent                  # local-agent fleet (connector installs)
+aclade whoami                 # identity carried by the token
+```
+
+## Where does the AI run?
+
+On aclade.com — not on your machine. This SDK is the official client: it holds your token, sends work, and returns results. The reasoning harness, tools, and per-second metering are Aclade platform services — the same way `import stripe` never contains Stripe's rails.
+
+Optionally, your machine can also run the [zero-trust local connector](https://www.npmjs.com/package/aclade) (`npm i -g aclade`), which lets your experts act on your own filesystem, shell, and browser — outbound HTTPS polling only, no inbound ports.
+
+## Security notes
+
+- The token is a credential: anyone holding it can delegate work as your workspace (billed to your account). Keep it in an env var or secrets manager.
+- This package ships no AI logic, model weights, or telemetry.
+- License: proprietary (`UNLICENSED`), for users of the Aclade platform.

aclade-0.1.0/aclade/__init__.py

@@ -0,0 +1,9 @@
+"""aclade — the official Python SDK for Aclade, the autonomous AI workforce.
+
+The reasoning (the harness) runs on aclade.com infrastructure; this package
+is how you drive it from Python, the way ``import stripe`` drives Stripe.
+"""
+from .client import Aclade, AcladeError, load_token
+
+__version__ = "0.1.0"
+__all__ = ["Aclade", "AcladeError", "load_token", "__version__"]

aclade-0.1.0/aclade/cli.py

@@ -0,0 +1,132 @@
+"""Command line: ``aclade experts | run | tasks | agent | whoami``."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from . import __version__
+from .client import Aclade, AcladeError
+
+
+def _cmd_whoami(client, _args):
+    print(json.dumps(
+        {
+            "name": client.name,
+            "companyId": client.company_id,
+            "memberId": client.member_id,
+            "baseUrl": client.base_url,
+        },
+        indent=2,
+    ))
+    return 0
+
+
+def _cmd_experts(client, _args):
+    experts = client.experts()
+    if not experts:
+        print("No experts on this roster yet. Rent one in the portal: https://aclade.com")
+        return 0
+    for m in experts:
+        print("%-28s  %-22s  %s" % (m.get("name", "?"), m.get("role", "?"), m.get("title", "")))
+    return 0
+
+
+def _cmd_run(client, args):
+    try:
+        answers = json.loads(args.answers) if args.answers else None
+    except ValueError:
+        print("aclade: --answers must be valid JSON, e.g. '{\"stack\": \"node\"}'", file=sys.stderr)
+        return 2
+    result = client.delegate(args.expert, args.task, answers=answers)
+    status = result.get("status")
+    if status == "completed":
+        print((result.get("run") or {}).get("report") or "(no report)")
+        return 0
+    if status == "needs-input":
+        print("The expert needs input before proceeding:")
+        for q in result.get("questions") or []:
+            print("  -", q if isinstance(q, str) else json.dumps(q))
+        print('Re-run with: aclade run "%s" "%s" --answers \'<json>\'' % (args.expert, args.task))
+        return 0
+    if status == "needs-approval":
+        print("A high-risk step requires approval — the admin email link is on its way.")
+        return 0
+    print(json.dumps(result, indent=2))
+    return 0
+
+
+def _cmd_tasks(client, _args):
+    pending = (client.pending_tasks().get("pendingByExpert")) or {}
+    if not pending:
+        print("No pending tasks.")
+    for expert_id, n in pending.items():
+        print("%s: %d" % (expert_id, n))
+    return 0
+
+
+def _cmd_agent(client, _args):
+    data = client.connector_status()
+    print("Installs: %s   Online: %s" % (data.get("installs", 0), data.get("connected", 0)))
+    for a in data.get("agents") or []:
+        print(
+            "  %s %s — %s v%s — %s tasks — last seen %s"
+            % (
+                "●" if a.get("online") else "○",
+                a.get("hostname"),
+                a.get("platform"),
+                a.get("version"),
+                a.get("tasksExecuted", 0),
+                a.get("lastSeenAt"),
+            )
+        )
+    return 0
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="aclade",
+        description="Aclade — autonomous AI experts that do real work. "
+        "Delegate tasks from Python, and check your local-agent fleet.",
+    )
+    parser.add_argument("--version", action="version", version="aclade %s" % __version__)
+    parser.add_argument("--token", help="API token (default: $ACLADE_TOKEN, then ~/.aclade-agent.json)")
+    parser.add_argument("--host", default="https://aclade.com", help="Platform base URL")
+    sub = parser.add_subparsers(dest="command")
+
+    p = sub.add_parser("whoami", help="Show the identity carried by the token")
+    p.set_defaults(func=_cmd_whoami)
+
+    p = sub.add_parser("experts", help="List the AI experts on your roster")
+    p.set_defaults(func=_cmd_experts)
+
+    p = sub.add_parser("run", help="Delegate a task to an expert and wait for the report")
+    p.add_argument("expert", help="Expert id or name substring (see: aclade experts)")
+    p.add_argument("task", help="What the expert should do")
+    p.add_argument("--answers", help='JSON answers to clarifying questions, e.g. \'{"stack": "node"}\'')
+    p.set_defaults(func=_cmd_run)
+
+    p = sub.add_parser("tasks", help="Pending tasks by expert")
+    p.set_defaults(func=_cmd_tasks)
+
+    p = sub.add_parser("agent", help="Local-agent fleet for this workspace")
+    p.set_defaults(func=_cmd_agent)
+
+    args = parser.parse_args(argv)
+    if not getattr(args, "command", None):
+        parser.print_help()
+        return 0
+    try:
+        client = Aclade(token=args.token, base_url=args.host)
+    except AcladeError as e:
+        print("aclade: %s" % e, file=sys.stderr)
+        return 2
+    try:
+        return args.func(client, args)
+    except AcladeError as e:
+        print("aclade: %s" % e, file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

aclade-0.1.0/aclade/client.py

@@ -0,0 +1,221 @@
+"""HTTP client for the Aclade platform. Standard library only."""
+from __future__ import annotations
+
+import base64
+import json
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+
+__all__ = ["Aclade", "AcladeError", "load_token"]
+
+DEFAULT_BASE_URL = "https://aclade.com"
+
+
+class AcladeError(RuntimeError):
+    """The platform rejected a request (or no token was found)."""
+
+    def __init__(self, status, message):
+        super().__init__(("HTTP %s: %s" % (status, message)) if status else str(message))
+        self.status = status
+        self.message = message
+
+
+def load_token():
+    """Resolve the API token: $ACLADE_TOKEN, then the local-agent config.
+
+    Machines that already run the npm connector (``aclade connect``) keep
+    their token in ``~/.aclade-agent.json`` — so ``import aclade`` just works
+    there without any extra setup.
+    """
+    tok = os.environ.get("ACLADE_TOKEN", "").strip()
+    if tok:
+        return tok
+    candidates = (
+        os.path.join(os.path.expanduser("~"), ".aclade-agent.json"),
+        os.path.join(os.path.expanduser("~"), ".aclade", "token"),
+    )
+    for candidate in candidates:
+        try:
+            with open(candidate, "r", encoding="utf-8") as fh:
+                text = fh.read().strip()
+        except OSError:
+            continue
+        if not text:
+            continue
+        if text.startswith("{"):
+            try:
+                tok = (json.loads(text) or {}).get("token", "")
+            except ValueError:
+                tok = ""
+            if tok:
+                return tok
+        else:
+            return text
+    return None
+
+
+class Aclade:
+    """A client for the Aclade platform.
+
+    Example::
+
+        team = aclade.Aclade()
+        for e in team.experts():
+            print(e["name"], e["title"])
+        result = team.delegate("Priya", "Summarize our top 3 customer complaints")
+        print(result["run"]["report"])
+    """
+
+    def __init__(self, token=None, base_url=DEFAULT_BASE_URL, timeout=300):
+        self.token = token or load_token()
+        if not self.token:
+            raise AcladeError(
+                0,
+                "No Aclade token. Pass token=... or set ACLADE_TOKEN. "
+                "Issue one in the portal: https://aclade.com -> Settings -> Local Agent.",
+            )
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._claims = self._decode_claims(self.token)
+
+    @staticmethod
+    def _decode_claims(token):
+        """Session tokens are signed base64url JSON; a client may read its own."""
+        try:
+            body = token.split(".", 1)[0]
+            pad = body + "=" * (-len(body) % 4)
+            raw = base64.urlsafe_b64decode(pad.encode("ascii"))
+            return json.loads(raw.decode("utf-8"))
+        except Exception:
+            return {}
+
+    @property
+    def company_id(self):
+        return self._claims.get("companyId")
+
+    @property
+    def member_id(self):
+        return self._claims.get("memberId")
+
+    @property
+    def name(self):
+        return self._claims.get("name")
+
+    def _require_workspace(self):
+        if not self.company_id:
+            raise AcladeError(
+                0,
+                "This token does not carry workspace claims. Use a token issued "
+                "by the portal (Settings -> Local Agent).",
+            )
+        return self.company_id
+
+    def _request(self, method, path, body=None, timeout=None):
+        url = self.base_url + path
+        data = json.dumps(body).encode("utf-8") if body is not None else None
+        req = urllib.request.Request(url, data=data, method=method)
+        req.add_header("Authorization", "Bearer " + self.token)
+        req.add_header("Accept", "application/json")
+        if data is not None:
+            req.add_header("Content-Type", "application/json")
+        try:
+            with urllib.request.urlopen(req, timeout=timeout or self.timeout) as resp:
+                payload = resp.read().decode("utf-8")
+                return json.loads(payload) if payload else {}
+        except urllib.error.HTTPError as e:
+            detail = ""
+            try:
+                raw = e.read().decode("utf-8")
+                try:
+                    detail = (json.loads(raw) or {}).get("error") or raw[:300]
+                except ValueError:
+                    detail = raw[:300]
+            except Exception:
+                detail = str(e)
+            raise AcladeError(e.code, detail) from None
+        except urllib.error.URLError as e:
+            raise AcladeError(0, "Could not reach %s: %s" % (self.base_url, e.reason)) from None
+
+    # ---- Roster ----------------------------------------------------------------
+
+    def workspace(self):
+        """The durable company workspace: ``{"workspace": {company, members, ...}}``."""
+        cid = self._require_workspace()
+        return self._request("GET", "/api/workspace?companyId=" + urllib.parse.quote(cid))
+
+    def members(self):
+        """Everyone on the roster (humans and experts)."""
+        return (self.workspace().get("workspace") or {}).get("members") or []
+
+    def experts(self):
+        """The rented AI experts on your roster."""
+        return [m for m in self.members() if m.get("origin") == "rented"]
+
+    def expert(self, name_or_id):
+        """Find one expert by id or (case-insensitive) name substring."""
+        for m in self.experts():
+            if m.get("id") == name_or_id:
+                return m
+        for m in self.experts():
+            if name_or_id.lower() in (m.get("name") or "").lower():
+                return m
+        raise AcladeError(0, "No expert matching %r — see: aclade experts" % name_or_id)
+
+    # ---- Delegation ------------------------------------------------------------
+
+    @staticmethod
+    def _expert_payload(m):
+        """The expert context the platform's run endpoint expects."""
+        email = m.get("email") or ""
+        domain = email.split("@")[1] if "@" in email else "aclade.com"
+        expert = m.get("expert") or {}
+        integrations = expert.get("integrations") or []
+        return {
+            "id": m.get("id"),
+            "companyId": m.get("companyId"),
+            "name": m.get("name"),
+            "role": m.get("title") or m.get("role") or "Expert",
+            "roleId": m.get("role"),
+            "personaId": m.get("personaId"),
+            "companyDomain": domain,
+            "email": email,
+            "activities": expert.get("activities") or [],
+            "integrations": [i.get("type") for i in integrations if isinstance(i, dict)],
+            "replacingName": expert.get("replacingName"),
+            "replacingContext": expert.get("replacingContext"),
+        }
+
+    def delegate(self, expert, task, answers=None, attachments=None):
+        """Hand a task to an expert and block until the platform returns.
+
+        ``expert`` may be a member dict from :meth:`experts`/:meth:`expert` or
+        a name/id string. Returns the result dict:
+
+        * ``status == "completed"``      → ``result["run"]["report"]`` has the work
+        * ``status == "needs-input"``    → ``result["questions"]``; re-call with
+          ``answers={...}`` to continue
+        * ``status == "needs-approval"`` → a high-risk step awaits a human; the
+          admin gets an approve/deny email (approve in the portal)
+        """
+        if isinstance(expert, str):
+            expert = self.expert(expert)
+        body = {"expert": self._expert_payload(expert), "task": task}
+        if answers is not None:
+            body["answers"] = answers
+        if attachments is not None:
+            body["attachments"] = attachments
+        return self._request("POST", "/api/experts/run", body=body)
+
+    # ---- Observability -----------------------------------------------------------
+
+    def pending_tasks(self):
+        """Tasks queued right now, by expert: ``{"pendingByExpert": {...}}``."""
+        self._require_workspace()
+        return self._request("GET", "/api/tenant/pending-tasks")
+
+    def connector_status(self):
+        """Local-agent fleet for this workspace, as seen by aclade.com."""
+        self._require_workspace()
+        return self._request("GET", "/api/connector/token")

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

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: aclade
+Version: 0.1.0
+Summary: Official Python SDK for Aclade — autonomous AI experts that do real work. `import aclade`, delegate a task, read the report.
+Author-email: Aclade <support@aclade.com>
+License: Proprietary (UNLICENSED) — distributed exclusively for users of the Aclade platform
+Project-URL: Homepage, https://aclade.com
+Project-URL: npm (local connector), https://www.npmjs.com/package/aclade
+Keywords: aclade,ai,agent,autonomous,experts,sdk,api
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# aclade
+
+**The official Python SDK for [Aclade](https://aclade.com)** — autonomous AI experts that do real work.
+
+`import aclade` and you can list your AI team, delegate tasks to individual experts, and read their reports — from any Python code, notebook, or pipeline.
+
+## Install
+
+```bash
+pip install aclade
+```
+
+Python 3.8+, zero third-party dependencies (standard library only).
+
+## Get a token
+
+1. Sign in at [aclade.com](https://aclade.com)
+2. **Settings → Local Agent → Get connection token** (the same token the local connector uses)
+3. `export ACLADE_TOKEN=<TOKEN>`
+
+Tokens are signed 12-hour sessions bound to your workspace. If you already connected a machine with the [npm connector](https://www.npmjs.com/package/aclade), the SDK picks the token up from `~/.aclade-agent.json` automatically — `import aclade` just works.
+
+## Quickstart
+
+```python
+import aclade
+
+team = aclade.Aclade()                    # token from $ACLADE_TOKEN or ~/.aclade-agent.json
+team = aclade.Aclade(token="<TOKEN>")     # …or explicitly
+
+# Who's on the roster?
+for e in team.experts():
+    print(e["name"], "—", e["title"])
+
+# Delegate a task and wait for the report
+result = team.delegate("Priya", "Summarize our top 3 customer complaints and draft replies")
+print(result["status"])                   # completed | needs-input | needs-approval
+print(result["run"]["report"])
+```
+
+## The three outcomes
+
+| `result["status"]` | Meaning | What to do |
+|---|---|---|
+| `completed` | The expert finished the work | Read `result["run"]["report"]` |
+| `needs-input` | The expert asked clarifying questions | Re-call with `answers={"<question>": "<answer>"}` |
+| `needs-approval` | A high-risk step awaits a human | Approve in the portal (email link goes to your admin) |
+
+## CLI
+
+```bash
+aclade experts                # roster
+aclade run "Priya" "task"     # delegate + print the report
+aclade tasks                  # pending tasks by expert
+aclade agent                  # local-agent fleet (connector installs)
+aclade whoami                 # identity carried by the token
+```
+
+## Where does the AI run?
+
+On aclade.com — not on your machine. This SDK is the official client: it holds your token, sends work, and returns results. The reasoning harness, tools, and per-second metering are Aclade platform services — the same way `import stripe` never contains Stripe's rails.
+
+Optionally, your machine can also run the [zero-trust local connector](https://www.npmjs.com/package/aclade) (`npm i -g aclade`), which lets your experts act on your own filesystem, shell, and browser — outbound HTTPS polling only, no inbound ports.
+
+## Security notes
+
+- The token is a credential: anyone holding it can delegate work as your workspace (billed to your account). Keep it in an env var or secrets manager.
+- This package ships no AI logic, model weights, or telemetry.
+- License: proprietary (`UNLICENSED`), for users of the Aclade platform.

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

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+aclade/__init__.py
+aclade/cli.py
+aclade/client.py
+aclade.egg-info/PKG-INFO
+aclade.egg-info/SOURCES.txt
+aclade.egg-info/dependency_links.txt
+aclade.egg-info/entry_points.txt
+aclade.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

aclade-0.1.0/aclade.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aclade = aclade.cli:main

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

@@ -0,0 +1 @@
+aclade

aclade-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aclade"
+version = "0.1.0"
+description = "Official Python SDK for Aclade — autonomous AI experts that do real work. `import aclade`, delegate a task, read the report."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "Proprietary (UNLICENSED) — distributed exclusively for users of the Aclade platform" }
+authors = [{ name = "Aclade", email = "support@aclade.com" }]
+keywords = ["aclade", "ai", "agent", "autonomous", "experts", "sdk", "api"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: Other/Proprietary License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.8",
+  "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",
+]
+
+[project.urls]
+Homepage = "https://aclade.com"
+"npm (local connector)" = "https://www.npmjs.com/package/aclade"
+
+[project.scripts]
+aclade = "aclade.cli:main"
+
+[tool.setuptools]
+packages = ["aclade"]

aclade-0.1.0/setup.cfg

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