smartypants-network 0.1.0__tar.gz

smartypants_network-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Howcan (Smarty Pants)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

smartypants_network-0.1.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: smartypants-network
+Version: 0.1.0
+Summary: Smarty Pants for agents: exact open models priced per token, plus sealed Linux workspaces on idle Macs. Standard library only.
+License: MIT
+Project-URL: Homepage, https://smartypants.network/docs/agents
+Project-URL: Source, https://github.com/Howcanio/smarty-pants
+Keywords: llm,openai-compatible,mcp,agents,sandbox,apple-silicon
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# smartypants-network (Python)
+
+The [Smarty Pants](https://smartypants.network/docs/agents) Python kit as an installable package.
+Python 3.8 or newer, standard library only.
+
+```sh
+pip install smartypants-network
+```
+
+```python
+from smartypants_network import SmartyPants
+sp = SmartyPants()                       # reads SMARTYPANTS_API_KEY
+print(sp.ask("Say hello in five words."))
+with sp.workspace(minutes=10) as ws:     # one VM, many commands (our own account first)
+    ws.put_file("data.txt", "hello")
+    print(ws.run("sh", "cat data.txt | wc -c")["stdout"])
+```
+
+The module is `smartypants_network`, not `smartypants`, because PyPI already has an unrelated
+`smartypants` package. The one-file download at https://smartypants.network/kits/smartypants.py
+keeps `from smartypants import SmartyPants`.
+
+For the command line, use the `smartypants` tool from the npm package (see `packages/cli`).
+
+Build from the repo root:
+
+```sh
+node packages/cli/scripts/sync-kits.mjs          # copies apps/gateway/agent-kit/smartypants.py here
+python3 -m pip wheel --no-deps -w packages/python/dist packages/python
+```
+
+MIT licence. Published by the "Publish agent packages" workflow; bump `version` in pyproject.toml first.

smartypants_network-0.1.0/README.md

@@ -0,0 +1,32 @@
+# smartypants-network (Python)
+
+The [Smarty Pants](https://smartypants.network/docs/agents) Python kit as an installable package.
+Python 3.8 or newer, standard library only.
+
+```sh
+pip install smartypants-network
+```
+
+```python
+from smartypants_network import SmartyPants
+sp = SmartyPants()                       # reads SMARTYPANTS_API_KEY
+print(sp.ask("Say hello in five words."))
+with sp.workspace(minutes=10) as ws:     # one VM, many commands (our own account first)
+    ws.put_file("data.txt", "hello")
+    print(ws.run("sh", "cat data.txt | wc -c")["stdout"])
+```
+
+The module is `smartypants_network`, not `smartypants`, because PyPI already has an unrelated
+`smartypants` package. The one-file download at https://smartypants.network/kits/smartypants.py
+keeps `from smartypants import SmartyPants`.
+
+For the command line, use the `smartypants` tool from the npm package (see `packages/cli`).
+
+Build from the repo root:
+
+```sh
+node packages/cli/scripts/sync-kits.mjs          # copies apps/gateway/agent-kit/smartypants.py here
+python3 -m pip wheel --no-deps -w packages/python/dist packages/python
+```
+
+MIT licence. Published by the "Publish agent packages" workflow; bump `version` in pyproject.toml first.

smartypants_network-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+# The Python kit (apps/gateway/agent-kit/smartypants.py) as an installable package.
+# Build: node packages/cli/scripts/sync-kits.mjs && python3 -m pip wheel --no-deps -w dist packages/python
+# Published by .github/workflows/publish-agent-packages.yml (Nat approved MIT and the name, 9 Nov 2026).
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "smartypants-network"
+version = "0.1.0"
+description = "Smarty Pants for agents: exact open models priced per token, plus sealed Linux workspaces on idle Macs. Standard library only."
+readme = "README.md"
+requires-python = ">=3.8"
+keywords = ["llm", "openai-compatible", "mcp", "agents", "sandbox", "apple-silicon"]
+license = {text = "MIT"}
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://smartypants.network/docs/agents"
+Source = "https://github.com/Howcanio/smarty-pants"
+
+[tool.setuptools]
+py-modules = ["smartypants_network"]

smartypants_network-0.1.0/setup.cfg

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

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

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: smartypants-network
+Version: 0.1.0
+Summary: Smarty Pants for agents: exact open models priced per token, plus sealed Linux workspaces on idle Macs. Standard library only.
+License: MIT
+Project-URL: Homepage, https://smartypants.network/docs/agents
+Project-URL: Source, https://github.com/Howcanio/smarty-pants
+Keywords: llm,openai-compatible,mcp,agents,sandbox,apple-silicon
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# smartypants-network (Python)
+
+The [Smarty Pants](https://smartypants.network/docs/agents) Python kit as an installable package.
+Python 3.8 or newer, standard library only.
+
+```sh
+pip install smartypants-network
+```
+
+```python
+from smartypants_network import SmartyPants
+sp = SmartyPants()                       # reads SMARTYPANTS_API_KEY
+print(sp.ask("Say hello in five words."))
+with sp.workspace(minutes=10) as ws:     # one VM, many commands (our own account first)
+    ws.put_file("data.txt", "hello")
+    print(ws.run("sh", "cat data.txt | wc -c")["stdout"])
+```
+
+The module is `smartypants_network`, not `smartypants`, because PyPI already has an unrelated
+`smartypants` package. The one-file download at https://smartypants.network/kits/smartypants.py
+keeps `from smartypants import SmartyPants`.
+
+For the command line, use the `smartypants` tool from the npm package (see `packages/cli`).
+
+Build from the repo root:
+
+```sh
+node packages/cli/scripts/sync-kits.mjs          # copies apps/gateway/agent-kit/smartypants.py here
+python3 -m pip wheel --no-deps -w packages/python/dist packages/python
+```
+
+MIT licence. Published by the "Publish agent packages" workflow; bump `version` in pyproject.toml first.

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

@@ -0,0 +1,8 @@
+LICENSE
+README.md
+pyproject.toml
+smartypants_network.py
+smartypants_network.egg-info/PKG-INFO
+smartypants_network.egg-info/SOURCES.txt
+smartypants_network.egg-info/dependency_links.txt
+smartypants_network.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+smartypants_network

smartypants_network-0.1.0/smartypants_network.py

@@ -0,0 +1,309 @@
+"""Smarty Pants starter kit for Python 3.8+. Standard library only, nothing to install.
+
+Docs: https://smartypants.network/docs/agents
+
+    from smartypants import SmartyPants
+    sp = SmartyPants()                      # reads SMARTYPANTS_API_KEY
+    print(sp.ask("Say hello in five words."))
+    print(sp.balance())
+    print(sp.run_code("python", "print(6 * 7)"))   # CPU jobs: our own account first, for now
+    with sp.workspace(minutes=10) as ws:            # one VM, many commands (our own account first)
+        ws.put_file("data.txt", "hello")
+        print(ws.run("sh", "cat data.txt | wc -c")["stdout"])
+
+Run this file directly for a quick check:
+    SMARTYPANTS_API_KEY=sp_live_... python3 smartypants.py
+
+Already use the OpenAI SDK? Point it here instead:
+    OpenAI(base_url="https://smartypants.network/v1", api_key=os.environ["SMARTYPANTS_API_KEY"])
+"""
+
+import base64
+import json
+import os
+import random
+import string
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+DEFAULT_BASE_URL = "https://smartypants.network"
+# No fixed model: the first call picks a ready text model from the live /v1/models list.
+# Pass model="smartypants/..." to choose one yourself.
+DEFAULT_MODEL = None
+
+
+def pick_text_model(models):
+    """The text model to use when none is given: a ready one first, then a released (active) one."""
+    text = [m for m in (models or []) if (m.get("kind") or "text") == "text"]
+    chosen = next((m for m in text if m.get("is_ready")), None) or next((m for m in text if m.get("status") == "active"), None) or (text[0] if text else None)
+    return chosen["id"] if chosen else None
+_DONE = {"succeeded", "failed", "timed_out", "cancelled", "expired"}
+
+
+class SmartyPantsError(Exception):
+    def __init__(self, message, status=None, code=None, body=None):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.body = body
+
+
+class SmartyPants:
+    def __init__(self, api_key=None, base_url=None, model=DEFAULT_MODEL, timeout=120):
+        self.api_key = api_key or os.environ.get("SMARTYPANTS_API_KEY") or os.environ.get("SMARTY_PANTS_API_KEY")
+        self.base_url = (base_url or os.environ.get("SMARTYPANTS_BASE_URL") or os.environ.get("SMARTY_PANTS_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+        self.model = model
+        self.timeout = timeout
+        self._rpc_id = 0
+
+    def request(self, method, path, body=None, auth=True, headers=None):
+        if auth and not self.api_key:
+            raise SmartyPantsError("No API key. Set SMARTYPANTS_API_KEY (create one at https://smartypants.network/api).")
+        h = {"Accept": "application/json", "User-Agent": "smartypants-python-kit/1"}
+        if body is not None:
+            h["Content-Type"] = "application/json"
+        if auth:
+            h["Authorization"] = "Bearer " + self.api_key
+        h.update(headers or {})
+        data = None if body is None else json.dumps(body).encode()
+        req = urllib.request.Request(self.base_url + path, data=data, method=method, headers=h)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                text = resp.read().decode()
+                return json.loads(text) if text else None
+        except urllib.error.HTTPError as e:
+            text = e.read().decode(errors="replace")
+            try:
+                parsed = json.loads(text)
+            except ValueError:
+                parsed = text
+            err = parsed.get("error", parsed) if isinstance(parsed, dict) else {}
+            err = err if isinstance(err, dict) else {"message": str(err)}
+            message = err.get("message") or err.get("error_description") or "HTTP %d" % e.code
+            raise SmartyPantsError("%s %s failed (%d): %s" % (method, path, e.code, message),
+                                   status=e.code, code=err.get("code") or err.get("type"), body=parsed) from None
+
+    def models(self):
+        """Every model with exact id, price per token and is_ready."""
+        return self.request("GET", "/v1/models")["data"]
+
+    def chat(self, messages, **options):
+        """OpenAI-format chat completion. Extra OpenAI fields go in **options."""
+        body = {"model": self.text_model(), "max_tokens": 512}
+        body.update(options)
+        body["messages"] = messages
+        return self.request("POST", "/v1/chat/completions", body)
+
+    def text_model(self):
+        """The model chat() uses: the one you passed, or a ready text model from the live list (looked up once)."""
+        if not self.model:
+            self.model = pick_text_model(self.models())
+            if not self.model:
+                raise SmartyPantsError("No text model is offered right now. See https://smartypants.network/v1/models.")
+        return self.model
+
+    def ask(self, prompt, system=None, thinking=False, **options):
+        """One prompt in, the answer text out. Thinking is off unless thinking=True."""
+        messages = ([{"role": "system", "content": system}] if system else []) + [{"role": "user", "content": prompt}]
+        options.setdefault("reasoning", {"enabled": thinking})
+        reply = self.chat(messages, **options)
+        return ((reply.get("choices") or [{}])[0].get("message") or {}).get("content") or ""
+
+    def _rpc(self, method, params=None, path="/mcp/account"):
+        self._rpc_id += 1
+        payload = {"jsonrpc": "2.0", "id": self._rpc_id, "method": method}
+        if params is not None:
+            payload["params"] = params
+        return self.request("POST", path, payload, auth=path != "/mcp",
+                            headers={"Accept": "application/json, text/event-stream"})
+
+    def mcp(self, tool, arguments=None, path="/mcp/account"):
+        """Call a tool on the MCP server. Signed-in tools live at /mcp/account; the no-sign-in ones at /mcp."""
+        rpc = self._rpc("tools/call", {"name": tool, "arguments": arguments or {}}, path)
+        if rpc.get("error"):
+            raise SmartyPantsError("MCP %s: %s" % (tool, rpc["error"].get("message")), code=rpc["error"].get("code"), body=rpc)
+        result = rpc.get("result") or {}
+        if result.get("isError"):
+            raise SmartyPantsError("MCP %s: %s" % (tool, (result.get("content") or [{}])[0].get("text", "tool error")), body=rpc)
+        if "structuredContent" in result:
+            return result["structuredContent"]
+        return json.loads((result.get("content") or [{}])[0].get("text") or "null")
+
+    def mcp_tools(self, path="/mcp/account"):
+        """Names of the MCP tools this key can use."""
+        return [t["name"] for t in (self._rpc("tools/list", path=path).get("result") or {}).get("tools", [])]
+
+    def balance(self):
+        """Balance in US dollars: available_usd, free_credit_usd, spent_this_month_usd."""
+        return self.mcp("get_balance")
+
+    def add_credit(self, amount_usd):
+        """A Stripe payment page for adding credit. This charges nothing: give the link to the
+        person you work for, and only they pay it. Never handle card details. The balance
+        updates about a minute after they pay."""
+        return self.mcp("add_credit", {"amount_usd": amount_usd})
+
+    def run_code(self, language, source, timeout_seconds=20, poll_seconds=5.0, wait_seconds=120):
+        """Run a short program in a sealed Linux VM on a Mac (no network, wiped after).
+
+        Open to our own account first; other accounts get
+        403 CPU_PILOT_ACCOUNT_REQUIRED until it opens. language is "python", "node" or "sh";
+        timeout_seconds 3 to 30. Returns a dict with id, status, exitCode, timedOut,
+        stdout, stderr, stdoutTruncated, stderrTruncated and chargeMicros.
+        """
+        key = "kit-%d-%s" % (int(time.time()), "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(8)))
+        job = self.request("POST", "/v1/cpu/jobs", {"runtime": "code-v1", "language": language, "source": source,
+                                                    "timeoutMs": int(timeout_seconds * 1000), "idempotencyKey": key})
+        job_id, status = job["id"], job.get("status")
+        quoted = urllib.parse.quote(job_id, safe="")
+        deadline = time.time() + wait_seconds
+        while status not in _DONE:
+            if time.time() > deadline:
+                raise SmartyPantsError("CPU job %s still %s after %d s" % (job_id, status, wait_seconds), code="WAIT_TIMEOUT")
+            time.sleep(poll_seconds)
+            status = self.request("GET", "/v1/cpu/jobs/" + quoted)["status"]
+        out = {}
+        if status in ("succeeded", "failed", "timed_out"):
+            try:
+                out = (self.request("GET", "/v1/cpu/jobs/%s/result" % quoted) or {}).get("result") or {}
+            except SmartyPantsError:
+                out = {}
+        try:
+            usage = self.request("GET", "/v1/cpu/jobs/%s/usage" % quoted)
+        except SmartyPantsError:
+            usage = None
+        rows = usage if isinstance(usage, list) else ([usage] if usage else [])
+        charges = [r["chargeMicros"] for r in rows if isinstance(r, dict) and isinstance(r.get("chargeMicros"), (int, float))]
+        return {"id": job_id, "status": status, "exitCode": out.get("exitCode"), "timedOut": out.get("timedOut", status == "timed_out"),
+                "stdout": out.get("stdout", ""), "stderr": out.get("stderr", ""),
+                "stdoutTruncated": out.get("stdoutTruncated", False), "stderrTruncated": out.get("stderrTruncated", False),
+                "chargeMicros": sum(charges) if charges else None}
+
+    def workspace(self, minutes=10, wait_seconds=120, poll_seconds=1.0, inference_budget_usd=None):
+        """Open a workspace: one sealed VM that keeps its files across many commands until it
+        ends (at most 2 hours, 10 minutes idle, or when the Mac's owner comes back).
+        Use it in a with block so it always ends. Our own account first, for now.
+        inference_budget_usd gives it its own Smarty Pants key (ws.inference["apiKey"] and
+        ws.inference["baseUrl"]) that spends at most that much and stops working when it ends."""
+        return Workspace(self, minutes, wait_seconds, poll_seconds, inference_budget_usd)
+
+
+class Workspace:
+    """One VM session. run() and put_file()/get_file() go to the guest one at a time."""
+
+    def __init__(self, sp, minutes, wait_seconds, poll_seconds, inference_budget_usd=None):
+        self.sp, self.poll_seconds = sp, poll_seconds
+        body = {"seconds": int(minutes * 60)}
+        if inference_budget_usd is not None:
+            body["inference"] = {"budgetMicros": int(round(inference_budget_usd * 1e6))}
+        session = sp.request("POST", "/v1/cpu/sessions", body)
+        self.id = session["id"]
+        self.inference = session.get("inference")
+        self._path = "/v1/cpu/sessions/" + urllib.parse.quote(self.id, safe="")
+        deadline = time.time() + wait_seconds
+        while session["status"] == "queued":
+            if time.time() > deadline:
+                self.close()
+                raise SmartyPantsError("workspace %s still waiting for a Mac after %d s" % (self.id, wait_seconds), code="WAIT_TIMEOUT")
+            time.sleep(poll_seconds)
+            session = self.status()
+        if session["status"] != "ready":
+            raise SmartyPantsError("workspace %s ended: %s" % (self.id, session.get("reason")), code=session.get("reason"))
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.close()
+
+    def status(self):
+        return self.sp.request("GET", self._path)
+
+    def close(self):
+        """End the workspace. Its VM, files and disk are destroyed."""
+        try:
+            return self.sp.request("DELETE", self._path)
+        except SmartyPantsError:
+            return None
+
+    def _wait(self, request_id, wait_seconds, on_output=None):
+        offsets = {"stdout": 0, "stderr": 0}
+        deadline = time.time() + wait_seconds
+        while True:
+            r = self.sp.request("GET", "%s/requests/%d?stdoutOffset=%d&stderrOffset=%d"
+                                % (self._path, request_id, offsets["stdout"], offsets["stderr"]))
+            for stream in ("stdout", "stderr"):
+                part = r.get(stream)
+                if part:
+                    if on_output and part["text"]:
+                        on_output(stream, part["text"])
+                    offsets[stream] = part["nextOffset"]
+            if r["done"]:
+                if r.get("error"):
+                    raise SmartyPantsError("workspace request %d failed: %s" % (request_id, r["error"]), code=r["error"])
+                return r
+            if time.time() > deadline:
+                raise SmartyPantsError("workspace request %d still running after %d s" % (request_id, wait_seconds), code="WAIT_TIMEOUT")
+            time.sleep(self.poll_seconds)
+
+    def run(self, language, source, timeout_seconds=60, on_output=None):
+        """Run a program ("python", "node" or "sh") in the workspace folder. on_output(stream, text)
+        gets output as it arrives. Returns exitCode, timedOut, stdout and stderr (4 KiB each)."""
+        rid = self.sp.request("POST", self._path + "/exec", {"language": language, "source": source,
+                                                              "timeoutSeconds": int(timeout_seconds)})["requestId"]
+        out = {"stdout": "", "stderr": ""}
+        def keep(stream, text):
+            out[stream] += text
+            if on_output:
+                on_output(stream, text)
+        r = self._wait(rid, timeout_seconds + 30, keep)
+        return {"exitCode": r.get("exitCode"), "timedOut": r.get("timedOut"), **out}
+
+    PIECE = 256 * 1024  # larger files move in pieces of this size, a few at a time
+    AHEAD = 4
+
+    def put_file(self, path, content):
+        """Write a file (text or bytes, up to 64 MiB) at a relative path in the workspace."""
+        data = content.encode("utf-8") if isinstance(content, str) else bytes(content)
+        if len(data) <= 8 * 1024:
+            rid = self.sp.request("POST", self._path + "/files",
+                                  {"path": path, "contentBase64": base64.b64encode(data).decode("ascii")})["requestId"]
+            self._wait(rid, 60)
+            return
+        waiting = []
+        for offset in range(0, len(data), self.PIECE):
+            piece = base64.b64encode(data[offset:offset + self.PIECE]).decode("ascii")
+            waiting.append(self.sp.request("POST", self._path + "/files",
+                                           {"path": path, "offset": offset, "contentBase64": piece})["requestId"])
+            if len(waiting) >= self.AHEAD:
+                self._wait(waiting.pop(0), 120)
+        for rid in waiting:
+            self._wait(rid, 120)
+
+    def get_file(self, path):
+        """Read a file (up to 64 MiB) from the workspace, as bytes."""
+        quoted = urllib.parse.quote(path, safe="/")
+        rid = self.sp.request("GET", self._path + "/files?path=" + quoted)["requestId"]
+        try:
+            return base64.b64decode(self._wait(rid, 60).get("contentBase64", ""))
+        except SmartyPantsError as error:
+            if error.code != "TOO_LARGE":
+                raise
+        piece = lambda offset: self.sp.request("GET", "%s/files?path=%s&offset=%d" % (self._path, quoted, offset))["requestId"]
+        first = self._wait(piece(0), 120)
+        size, parts = first["size"], [base64.b64decode(first.get("contentBase64", ""))]
+        offsets = list(range(self.PIECE, size, self.PIECE))
+        waiting = []
+        while offsets or waiting:
+            while offsets and len(waiting) < self.AHEAD:
+                waiting.append(piece(offsets.pop(0)))
+            parts.append(base64.b64decode(self._wait(waiting.pop(0), 120).get("contentBase64", "")))
+        return b"".join(parts)
+
+
+if __name__ == "__main__":
+    sp = SmartyPants()
+    print("Balance:", sp.balance())
+    print("Answer:", sp.ask("Name three planets, comma separated.", max_tokens=40))