stateweave-sdk 0.3.0__py3-none-any.whl

stateweave/__init__.py

@@ -0,0 +1,311 @@
+"""StateWeave's client for your own agent's harness. Start a run of a test, connect your agent to the fresh copies of
+the apps the run gets, then hand in its answer: the studio grades the run and shows it, with every call your agent
+made, on its page.
+
+    import stateweave
+
+    run = stateweave.start("t-3fa2c1", agent="my-agent@0.3")
+    answer = my_agent(run.prompt, run.apps)    # your harness, your agent, your code
+    result = run.finish(answer)
+    print(result.passed, result.reasons, result.url)
+
+Every test of a scenario, each run closed even when your agent raises:
+
+    for test in stateweave.tests(project="p-9c41d2"):
+        with stateweave.start(test["id"], agent="my-agent@0.3") as run:
+            run.finish(my_agent(run.prompt, run.apps))
+
+Besides runs, the client does what the studio's page does with a scenario (its environments), by API key:
+projects(), create_project(), data() and add_data() (data of your own, twin/additions.py), write_tests() (your
+requests, word for word) and suggest_tests() (Claude's ideas), faults() and fault_targets() (what tests may inject),
+job(), recheck().
+
+The studio's address and an API key (made on its Runs page) come from Client(url=..., api_key=...), else from
+STATEWEAVE_URL and STATEWEAVE_API_KEY, else from what `sw login` saved (config.py); the address is
+http://127.0.0.1:8700 when none says otherwise. Only the standard library is used. The command line is `sw`
+(python -m stateweave)."""
+from __future__ import annotations
+
+import dataclasses
+import json
+import os
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from . import config
+
+__all__ = ["Client", "Run", "Result", "StateWeaveError", "RunEnded", "start", "tests"]
+
+__version__ = "0.3.0"
+
+DEFAULT_URL = "http://127.0.0.1:8700"
+RETRIES = 3  # times a request the studio rate-limited (429) is sent again
+
+
+class StateWeaveError(Exception):
+    """The studio refused a request: `status` is the HTTP status, `body` what it said."""
+
+    def __init__(self, status: int, body: dict):
+        self.status, self.body = status, body
+        said = body.get("message") or "; ".join(body.get("problems") or []) or body.get("hint") or body.get("error")
+        super().__init__(f"HTTP {status}: {said or body}")
+
+
+class RunEnded(StateWeaveError):
+    """The run had ended already (finished, timed out or cancelled): `run` is how it ended."""
+
+    @property
+    def run(self) -> dict | None:
+        return self.body.get("run")
+
+
+@dataclasses.dataclass
+class Result:
+    """How a run ended. status: passed, failed, timed_out, cancelled, interrupted or error (the test's own code
+    failed, not your agent)."""
+    id: str
+    status: str
+    passed: bool | None
+    reasons: list[str]
+    calls: int
+    url: str
+
+
+class Client:
+    def __init__(self, url: str | None = None, api_key: str | None = None, timeout: float = 300):
+        saved = config.load()
+        self.url = (url or os.environ.get("STATEWEAVE_URL") or saved.get("url") or DEFAULT_URL).rstrip("/")
+        self.api_key = api_key or os.environ.get("STATEWEAVE_API_KEY") or saved.get("api_key")
+        self.timeout = timeout  # starting a run serves its apps, and finishing grades it: both take a few seconds
+        if not self.api_key:
+            raise ValueError("no API key: run `sw login`, or make one on the studio's Runs page and set "
+                             "STATEWEAVE_API_KEY")
+
+    # ---------------------------------------------------------------- who and where
+    def me(self) -> dict:
+        """{"studio": its address, "name": the hosted studio's name or None, "key": {"id", "name"}}."""
+        return self.request("GET", "/api/v1/me")
+
+    # ---------------------------------------------------------------- scenarios (projects) and their data
+    def projects(self) -> list[dict]:
+        """Every scenario, newest first: {"id", "title", "status", "apps", "envs": {app: {"counts", "summary",
+        "state"}}, ...}; no credentials."""
+        return self.request("GET", "/api/v1/projects")["projects"]
+
+    def project(self, project: str) -> dict:
+        return self.request("GET", f"/api/v1/projects/{_q(project)}")
+
+    def create_project(self, description: str, apps: list[str], *, company: str | None = None,
+                       people: int | None = None, weeks: int | None = None, content: str | None = None) -> dict:
+        """A new scenario, generated in the background: follow it with project(id) until its status is ready.
+        `content`: "auto" (Claude when the studio has it), "llm" or "templates"."""
+        options = {k: v for k, v in (("company", company), ("people", people), ("weeks", weeks),
+                                     ("content", content)) if v is not None}
+        return self.request("POST", "/api/v1/projects", {"description": description, "apps": apps,
+                                                         "options": options})
+
+    def data(self, project: str) -> dict:
+        """{"kinds": {app: {kind: {"title", "fields", "example"}}}, "additions": [what was added]}."""
+        return self.request("GET", f"/api/v1/projects/{_q(project)}/data")
+
+    def add_data(self, project: str, app: str, kind: str, items: list[dict]) -> dict:
+        """Add items of your own (e.g. app "gmail", kind "email"); the app's tests then need a re-check.
+        Returns {"addition", "counts", "stale"}; a bad item raises StateWeaveError with every problem."""
+        return self.request("POST", f"/api/v1/projects/{_q(project)}/data", {"app": app, "kind": kind,
+                                                                             "items": items})
+
+    # ---------------------------------------------------------------- writing tests
+    def write_tests(self, project: str, requests: list[str | dict], faults: list[str] | None = None, *,
+                    noise: dict | None = None, pinned: list[dict] | None = None,
+                    difficulty: str | None = None) -> dict:
+        """One test per request you wrote, kept word for word (a string, or {"text", "criteria"?, "kind"?,
+        "apps"?}; criteria: what a right outcome must meet, in your words); returns the job: follow it with
+        job(project, id). A request that cannot be a test as written ends "rejected", with why and a wording that
+        would work. Faults, one way at most: `faults` (preset ids, from faults()), `noise` (random injection:
+        {"rate"?, "kinds"?, "max"?, "max_hang"?, "max_outage"?}, {} for the defaults) or `pinned` (faults at
+        endpoints: [{"app", "endpoint", "kind", "nth"?, "seconds"?, "cut"?}], from fault_targets())."""
+        return self.request("POST", f"/api/v1/projects/{_q(project)}/tests",
+                            {"requests": requests, **_faults(faults, noise, pinned),
+                             **({"difficulty": difficulty} if difficulty else {})})
+
+    def suggest_tests(self, project: str, count: int, focus: str = "", faults: list[str] | None = None,
+                      difficulty: str = "normal", *, noise: dict | None = None,
+                      pinned: list[dict] | None = None) -> dict:
+        """`count` tests (1 to 10) from Claude's own ideas, with an optional focus; returns the job. Faults as in
+        write_tests()."""
+        return self.request("POST", f"/api/v1/projects/{_q(project)}/tests",
+                            {"count": count, "focus": focus, "difficulty": difficulty,
+                             **_faults(faults, noise, pinned)})
+
+    def faults(self, project: str) -> list[dict]:
+        """The fault presets the project's tests may inject: {"id", "app", "kind", "title", "observed" (seen on the
+        real app, else carried over from another app's), "evidence"}."""
+        return self.request("GET", f"/api/v1/projects/{_q(project)}/faults")["presets"]
+
+    def fault_targets(self, project: str) -> dict:
+        """Where faults can be pinned: {"apps": {app: {"title", "endpoints": [...]}}, "kinds": {kind: what it does},
+        "noise": {"defaults", "limits"}}."""
+        return self.request("GET", f"/api/v1/projects/{_q(project)}/endpoints")
+
+    def job(self, project: str, job: str) -> dict:
+        """A job writing tests: its status and each item's ("pending", "writing", "checking", "ready", "failed",
+        "rejected")."""
+        return self.request("GET", f"/api/v1/projects/{_q(project)}/jobs/{_q(job)}")
+
+    def recheck(self, project: str, tests: list[str] | None = None) -> list[str]:
+        """Re-check stale tests (all of the project's, or these) on the data as it is now; returns their ids."""
+        return self.request("POST", f"/api/v1/projects/{_q(project)}/tests/recheck",
+                            {"tests": tests} if tests else {})["rechecking"]
+
+    # ---------------------------------------------------------------- runs
+
+    def tests(self, project: str | None = None) -> list[dict]:
+        """The tests you can run: {"id", "project", "title", "prompt", "kind", "apps", "answer_format", ...}."""
+        query = f"?{urllib.parse.urlencode({'project': project})}" if project else ""
+        return self.request("GET", f"/api/v1/tests{query}")["tests"]
+
+    def start(self, test: str, *, agent: str, project: str | None = None, timeout: float | None = None,
+              meta: dict | None = None) -> Run:
+        """Start a run of `test` for `agent` (a label your runs are compared by, e.g. "my-agent@0.3"). `timeout`:
+        seconds before the studio ends it unfinished (30 minutes when unset); `meta`: anything you want shown with
+        it (model, prompt version, commit)."""
+        body = {"test": test, "agent": agent, "project": project, "timeout": timeout, "meta": meta}
+        return Run(self, self.request("POST", "/api/v1/runs", {k: v for k, v in body.items() if v is not None}))
+
+    def run(self, run_id: str) -> Run:
+        """A run you started, as it stands now."""
+        return Run(self, self.request("GET", f"/api/v1/runs/{run_id}"))
+
+    def next_run(self, worker: str, *, agent: str, meta: dict | None = None, timeout: float | None = None,
+                 wait: float = 25) -> Run | None:
+        """As a worker (`worker`: an id of your own, the same on every call), wait up to `wait` seconds for a run
+        someone asked for on the studio's pages (Run again); it comes started, labelled `agent`, like start()'s. None
+        when none came. Calling it is what keeps the worker listed as connected there."""
+        body = {"worker": worker, "agent": agent, "meta": meta, "timeout": timeout, "wait": wait}
+        data = self.request("POST", "/api/v1/workers/next", {k: v for k, v in body.items() if v is not None})
+        return Run(self, data) if data.get("id") else None
+
+    def leave(self, worker: str) -> None:
+        """The worker stops: the studio no longer lists it or queues runs for it."""
+        self.request("POST", f"/api/v1/workers/{_q(worker)}/leave")
+
+    def request(self, method: str, path: str, body: dict | None = None) -> dict:
+        data = None if body is None else json.dumps(body).encode()
+        req = urllib.request.Request(self.url + path, data=data, method=method,
+                                     headers={"Authorization": f"Bearer {self.api_key}",
+                                              "Content-Type": "application/json", "Accept": "application/json"})
+        for attempt in range(RETRIES + 1):
+            try:
+                with urllib.request.urlopen(req, timeout=self.timeout) as res:
+                    return json.loads(res.read() or b"{}")
+            except urllib.error.HTTPError as e:
+                try:
+                    said = json.loads(e.read() or b"{}")
+                except ValueError:
+                    said = {"error": e.reason}
+                if e.code == 429 and said.get("error") == "rate_limited" and attempt < RETRIES:
+                    # a hosted studio's per-key rate limit, not a limit of the workspace's: wait as it says
+                    time.sleep(min(float(e.headers.get("retry-after") or 1), 10))
+                    continue
+                raise (RunEnded if e.code == 409 and said.get("run") else StateWeaveError)(e.code, said) from None
+            except urllib.error.URLError as e:  # no answer at all: a wrong address, or the studio is down
+                raise ConnectionError(f"cannot reach {self.url}: {getattr(e.reason, 'strerror', None) or e.reason}") \
+                    from None
+        raise AssertionError("unreachable")  # the loop returns or raises
+
+
+class Run:
+    """A run of a test. While it runs: `prompt` (what to ask your agent), `kind` ("answer": the agent answers;
+    "action": it changes the apps), `answer_format`, `persona` (whom the agent acts as) and `apps`: per app its
+    base_url, endpoints, credentials and the MCP server those credentials open ({"url", "headers"}, or None)."""
+
+    def __init__(self, client: Client, data: dict):
+        self.client = client
+        self._set(data)
+
+    def _set(self, data: dict) -> None:
+        self.data = data
+        self.id: str = data["id"]
+        self.test: str = data["test"]
+        self.status: str = data["status"]
+        self.url: str = data.get("url", "")
+        self.prompt: str = data.get("prompt", "")
+        self.kind: str = data.get("kind", "")
+        self.answer_format: str = data.get("answer_format", "")
+        self.persona: dict = data.get("persona") or {}
+        self.apps: dict = data.get("apps") or {}
+        self.expires_at: float | None = data.get("expires_at")
+
+    def credential(self, app: str, kind: str = "user") -> str | None:
+        """The first credential of `app` whose label starts with `kind` ("user", "bot", "app", "mcp", "setup")."""
+        creds = self.apps.get(app, {}).get("credentials", {})
+        return next((v for label, v in creds.items() if label.split(":", 1)[0] == kind), None)
+
+    def mcp_servers(self) -> dict:
+        """The apps' MCP servers as Claude Code and the Claude Agent SDK take them: {app: {"type": "http", "url",
+        "headers"}}."""
+        return {app: {"type": "http", **a["mcp"]} for app, a in self.apps.items() if a.get("mcp")}
+
+    def finish(self, answer=None) -> Result:
+        """Hand in the agent's answer (the JSON value answer_format describes; nothing for an action test): the
+        studio grades the run on what the agent left in the apps and the answer."""
+        data = self.client.request("POST", f"/api/v1/runs/{self.id}/finish", {"answer": answer})
+        self._set(data)
+        return self.result()
+
+    def cancel(self) -> Result:
+        """Give the run up: its apps stop, it is not graded."""
+        self._set(self.client.request("POST", f"/api/v1/runs/{self.id}/cancel"))
+        return self.result()
+
+    def result(self) -> Result:
+        d = self.data
+        return Result(d["id"], d["status"], d.get("passed"), list(d.get("reasons") or []), d.get("calls") or 0,
+                      self.url)
+
+    def __enter__(self) -> Run:
+        return self
+
+    def __exit__(self, *exc) -> None:
+        if self.status == "running":  # left without finishing, or the agent raised: give it up, keep what it did
+            try:
+                self.cancel()
+            except RunEnded:
+                pass
+
+    def __repr__(self) -> str:
+        return f"<Run {self.id} {self.test} {self.status}>"
+
+
+def _q(part: str) -> str:
+    return urllib.parse.quote(part, safe="")
+
+
+def _faults(faults: list[str] | None, noise: dict | None, pinned: list[dict] | None) -> dict:
+    if sum(x is not None and x != [] for x in (faults, noise, pinned)) > 1:
+        raise ValueError("faults, noise and pinned: one of them at most")
+    return {"faults": faults} if faults else {"noise": noise} if noise is not None else \
+        {"pinned": pinned} if pinned else {}
+
+
+_default: Client | None = None
+
+
+def _client() -> Client:
+    global _default
+    if _default is None:
+        _default = Client()
+    return _default
+
+
+def start(test: str, *, agent: str, project: str | None = None, timeout: float | None = None,
+          meta: dict | None = None) -> Run:
+    """Client().start(...) with the address and key from the environment."""
+    return _client().start(test, agent=agent, project=project, timeout=timeout, meta=meta)
+
+
+def tests(project: str | None = None) -> list[dict]:
+    """Client().tests(...) with the address and key from the environment."""
+    return _client().tests(project)

stateweave/__main__.py

@@ -0,0 +1,537 @@
+"""`sw`, StateWeave from a shell (python -m stateweave works too).
+
+    sw login [--url URL] [--key sw_…]          check the key with the studio, then keep both (config.py)
+    sw whoami | sw logout | sw --version
+
+    sw env ls | sw env show ENV
+    sw env new --apps gmail,slack --describe "…" [--company NAME] [--people N] [--weeks N] [--templates] [--no-wait]
+
+    sw data kinds ENV                          what each app of ENV takes, field by field
+    sw data add ENV APP KIND --FIELD VALUE …   one item, e.g. sw data add p-1 gmail email --from dana@x.com
+                                               --subject "Credit?" --body-file mail.txt (--X-file reads X from a file)
+    sw data add ENV APP KIND --file items.json a JSON list of items
+
+    sw task ls [--env ENV]
+    sw task new ENV --request "…" [--criteria "…"] | --request … --request … | --file requests.txt
+                    | --suggest N [--focus "…"] [--hard]
+                    [--faults ID,ID | --random-faults [RATE]] [--no-wait]
+    sw task faults ENV                         the fault presets ENV's tests may inject
+    sw task recheck ENV [TASK …]
+
+    sw run TASK --agent LABEL [--env ENV] [--timeout S] [--json] -- COMMAND …
+    sw worker --agent LABEL [--timeout S] [--once] [--json] -- COMMAND …
+    sw mcp-config RUN                          a live run's MCP servers, as Claude Code's --mcp-config takes them
+
+    sw tests | start | finish | cancel         the run endpoints one call at a time, as JSON
+
+`sw run` starts a run of TASK, runs COMMAND (your agent, in any language) with the run in its environment, then
+hands in the answer and prints the result:
+
+    STATEWEAVE_RUN          the run's id
+    STATEWEAVE_PROMPT       what to ask your agent
+    STATEWEAVE_KIND         answer (it finds something out) or action (it changes the apps)
+    STATEWEAVE_ANSWER_FORMAT  for an answer task, the JSON value to answer with
+    STATEWEAVE_RUN_FILE     the whole run as JSON: per app its base_url, endpoints, credentials, MCP server
+    STATEWEAVE_MCP_CONFIG   {"mcpServers": {...}}: claude -p "$STATEWEAVE_PROMPT" --mcp-config "$STATEWEAVE_MCP_CONFIG"
+    STATEWEAVE_ANSWER_FILE  where to write the answer (JSON, or plain text); nothing for an action task
+
+The run is graded when COMMAND exits, whatever its exit code; Ctrl-C gives the run up instead. `sw run` exits 0
+when the run passed, 1 when it did not.
+
+`sw worker` waits for the runs someone asks for on the studio's pages (Run again on a run's page) and drives each the
+same way, as LABEL, until Ctrl-C. COMMAND starts afresh for every run, so a change to your agent counts from the next
+run on, without restarting the worker. The runs show the command, this machine's name and, in a git checkout, the
+commit the worker runs at."""
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import getpass
+import json
+import os
+import pathlib
+import secrets
+import shutil
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+
+from . import DEFAULT_URL, Client, RunEnded, StateWeaveError, __version__, config
+
+POLL = 2.0  # seconds between looks at something the studio does in the background
+AWAY = 5.0  # seconds a worker waits before asking again when the studio cannot be reached
+
+
+def main(argv=None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    command = []
+    if "--" in argv:  # sw run TASK … -- the agent's own command line
+        cut = argv.index("--")
+        argv, command = argv[:cut], argv[cut + 1:]
+    parser = _parser()
+    a, extra = parser.parse_known_args(argv)
+    if extra and not (a.command == "data" and a.what == "add"):
+        parser.error(f"unrecognized arguments: {' '.join(extra)}")
+    a.extra, a.agent_command = extra, command
+    try:
+        return COMMANDS[a.command](a)
+    except StateWeaveError as e:
+        said, problems = e.body.get("message"), e.body.get("problems") or []
+        # the problems one to a line, each once (the error's own text is the first of them when there is no message)
+        print(f"sw: {e}" if said or not problems else f"sw: the studio refused it (HTTP {e.status}):", file=sys.stderr)
+        for problem in problems:
+            if problem != said:
+                print(f"  {problem}", file=sys.stderr)
+        return 1
+    except (ValueError, OSError) as e:
+        print(f"sw: {e}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        return 130
+
+
+def _parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="sw", description="StateWeave: environments, tests and runs of your own agent",
+                                epilog="Documentation: https://stateweave.net/docs/")
+    p.add_argument("--version", action="version", version=f"sw {__version__}")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    login = sub.add_parser("login", help="keep the studio's address and your API key")
+    login.add_argument("--url", help=f"the studio's address (default: the one kept, else {DEFAULT_URL})")
+    login.add_argument("--key", help="the API key (default: asked for, not echoed)")
+    sub.add_parser("logout", help="forget them")
+    sub.add_parser("whoami", help="which studio and key")
+
+    env = sub.add_parser("env", help="scenarios: their environments")
+    env_sub = env.add_subparsers(dest="what", required=True)
+    env_sub.add_parser("ls", help="every scenario")
+    show = env_sub.add_parser("show", help="one scenario")
+    show.add_argument("env")
+    new = env_sub.add_parser("new", help="generate a scenario")
+    new.add_argument("--apps", required=True, help="comma-separated, e.g. gmail,slack")
+    new.add_argument("--describe", required=True, help="the company and what the agent will be tested on")
+    new.add_argument("--company")
+    new.add_argument("--people", type=int)
+    new.add_argument("--weeks", type=int)
+    new.add_argument("--templates", action="store_true", help="templates only, no Claude (quick, plainer text)")
+    new.add_argument("--no-wait", action="store_true", help="print its id and return while it generates")
+
+    data = sub.add_parser("data", help="data of your own in a scenario's apps")
+    data_sub = data.add_subparsers(dest="what", required=True)
+    kinds = data_sub.add_parser("kinds", help="what each app takes")
+    kinds.add_argument("env")
+    add = data_sub.add_parser("add", help="add items (--FIELD VALUE …, or --file)", allow_abbrev=False)
+    add.add_argument("env")
+    add.add_argument("app")
+    add.add_argument("kind")
+    add.add_argument("--file", help="a JSON list of items (or one item)")
+
+    task = sub.add_parser("task", help="tests")
+    task_sub = task.add_subparsers(dest="what", required=True)
+    ls = task_sub.add_parser("ls", help="the tests you can run")
+    ls.add_argument("--env")
+    tnew = task_sub.add_parser("new", help="write tests: yours, word for word, or Claude's")
+    tnew.add_argument("env")
+    tnew.add_argument("--request", action="append", help="a request, as the agent will be asked it (repeatable)")
+    tnew.add_argument("--criteria", help="with one --request: what a right outcome must meet, in your words")
+    tnew.add_argument("--file", help="requests, a blank line between them")
+    tnew.add_argument("--suggest", type=int, metavar="N", help="instead: N tests from Claude's own ideas")
+    tnew.add_argument("--focus", default="", help="with --suggest: what they should be about")
+    tnew.add_argument("--hard", action="store_true", help="with --suggest: hard tests")
+    tnew.add_argument("--faults", help="comma-separated fault presets the tests may inject (sw task faults ENV)")
+    tnew.add_argument("--random-faults", nargs="?", const=-1.0, type=float, metavar="RATE",
+                      help="instead: faults injected at random into every app the tests use, on about RATE of the "
+                           "calls (default 0.05)")
+    tnew.add_argument("--no-wait", action="store_true", help="print the job's id and return while it writes")
+    faults = task_sub.add_parser("faults", help="the fault presets a scenario's tests may inject")
+    faults.add_argument("env")
+    recheck = task_sub.add_parser("recheck", help="re-check tests whose data changed")
+    recheck.add_argument("env")
+    recheck.add_argument("tasks", nargs="*")
+
+    run = sub.add_parser("run", help="run your agent on a test: sw run TASK --agent LABEL -- COMMAND …")
+    run.add_argument("task")
+    run.add_argument("--agent", required=True, help="the label runs are compared by, e.g. my-agent@0.3")
+    run.add_argument("--env", help="the scenario, when the task id is in several")
+    run.add_argument("--timeout", type=float, help="seconds before the studio ends it unfinished (default 1800)")
+    run.add_argument("--json", action="store_true", help="print the result as JSON")
+    worker = sub.add_parser("worker", help="drive the runs asked for on the studio's pages: sw worker --agent LABEL "
+                                           "-- COMMAND …")
+    worker.add_argument("--agent", required=True, help="the label its runs are compared by, e.g. my-agent@0.4")
+    worker.add_argument("--timeout", type=float, help="seconds before the studio ends a run unfinished (default: the "
+                                                      "time limit of the run it repeats)")
+    worker.add_argument("--once", action="store_true", help="drive one run, then stop")
+    worker.add_argument("--json", action="store_true", help="print each result as JSON")
+    mcp = sub.add_parser("mcp-config", help="a live run's MCP servers")
+    mcp.add_argument("run")
+
+    t = sub.add_parser("tests", help="the tests you can run, one per line")
+    t.add_argument("--project")
+    s = sub.add_parser("start", help="start a run; prints the request and the apps to connect to, as JSON")
+    s.add_argument("test")
+    s.add_argument("--agent", required=True, help="the label your runs are compared by, e.g. my-agent@0.3")
+    s.add_argument("--project")
+    s.add_argument("--timeout", type=float, help="seconds before the studio ends it unfinished (default 1800)")
+    f = sub.add_parser("finish", help="hand in the answer; prints the result")
+    f.add_argument("run")
+    f.add_argument("--answer", help="the answer as JSON (nothing for an action test)")
+    c = sub.add_parser("cancel", help="give a run up")
+    c.add_argument("run")
+    return p
+
+
+# ------------------------------------------------------------------ login
+def cmd_login(a) -> int:
+    url = (a.url or os.environ.get("STATEWEAVE_URL") or config.load().get("url") or DEFAULT_URL).rstrip("/")
+    key = a.key or getpass.getpass(f"API key for {url} (made on the studio's Runs page): ").strip()
+    try:
+        me = Client(url=url, api_key=key).me()  # a wrong key or address fails here, and nothing is kept
+    except StateWeaveError as e:
+        if e.status == 401:
+            raise ValueError(f"{url} did not accept that key: make one on its Runs page") from None
+        raise
+    path = config.save(url, key)
+    print(f"Signed in to {me.get('name') or me['studio']} as key “{me['key']['name']}”. Kept in {path}.")
+    return 0
+
+
+def cmd_logout(a) -> int:
+    print("Forgot the address and key." if config.clear() else "Nothing was kept.")
+    return 0
+
+
+def cmd_whoami(a) -> int:
+    client = Client()
+    me = client.me()
+    print(f"{client.url}  key “{me['key']['name']}” ({me['key']['id']})")
+    return 0
+
+
+# ------------------------------------------------------------------ scenarios
+def cmd_env(a) -> int:
+    client = Client()
+    if a.what == "ls":
+        _table([(p["id"], p["status"], ",".join(p["apps"]), p["title"]) for p in client.projects()])
+        return 0
+    if a.what == "show":
+        _show_project(client.project(a.env))
+        return 0
+    made = client.create_project(a.describe, [x.strip() for x in a.apps.split(",") if x.strip()],
+                                 company=a.company, people=a.people, weeks=a.weeks,
+                                 content="templates" if a.templates else None)
+    print(made["id"], flush=True)
+    if a.no_wait:
+        return 0
+    project = _follow_project(client, made["id"])
+    _show_project(project)
+    return 0 if project["status"] in ("ready", "partial") else 1
+
+
+def _follow_project(client: Client, pid: str) -> dict:
+    said: dict[str, str] = {}
+    while True:
+        project = client.project(pid)
+        for step in project["steps"]:
+            line = f"{step['title']}: {step['status']}" + (f" ({step['detail']})" if step.get("detail") else "")
+            if said.get(step["key"]) != step["status"]:
+                said[step["key"]] = step["status"]
+                print(f"  {line}", file=sys.stderr, flush=True)
+        if project["status"] != "generating":
+            return project
+        time.sleep(POLL)
+
+
+def _show_project(p: dict) -> None:
+    print(f"{p['id']}  {p['title']}  ({p['status']}{': ' + p['error'] if p.get('error') else ''})")
+    _table([(app, env["state"], ", ".join(f"{n} {k}" for k, n in env["counts"].items()))
+            for app, env in p["envs"].items()], indent="  ")
+
+
+def _table(rows: list[tuple], indent: str = "") -> None:
+    """Rows in columns as wide as their widest cell; the last column is left as it is."""
+    widths = [max(len(str(row[i])) for row in rows) for i in range(len(rows[0]) - 1)] if rows else []
+    for row in rows:
+        print(indent + "  ".join([str(c).ljust(w) for c, w in zip(row, widths)] + [str(row[-1])]))
+
+
+# ------------------------------------------------------------------ data
+def cmd_data(a) -> int:
+    client = Client()
+    kinds = client.data(a.env)["kinds"]
+    if a.what == "kinds":
+        for app, offered in kinds.items():
+            for kind, spec in offered.items():
+                print(f"{app} {kind}: {spec['title']}")
+                for name, f in spec["fields"].items():
+                    print(f"  --{name.replace('_', '-'):<20} {'' if f['required'] else '(optional) '}{f['help']}")
+        return 0
+    spec = kinds.get(a.app, {}).get(a.kind)
+    if a.file:
+        if a.extra:
+            raise ValueError("give the items in --file or as --FIELD VALUE, not both")
+        items = json.loads(pathlib.Path(a.file).read_text())
+        items = items if isinstance(items, list) else [items]
+    else:
+        items = [_item(a.extra, spec)]
+    out = client.add_data(a.env, a.app, a.kind, items)
+    stale = out.get("stale") or 0
+    print(f"Added {out['addition']['count']} {a.kind}(s) to {a.app}" +
+          (f"; {stale} test(s) need a re-check: sw task recheck {a.env}" if stale else "") + ".")
+    return 0
+
+
+def _item(tokens: list[str], spec: dict | None) -> dict:
+    """--FIELD VALUE pairs as one item; --FIELD-file PATH reads the value from a file. Lists (people, labels) are
+    comma-separated or JSON; objects are JSON. Field names may use - for _."""
+    fields = (spec or {}).get("fields", {})
+    item: dict = {}
+    if len(tokens) % 2:
+        raise ValueError(f"every --FIELD needs a value: {' '.join(tokens)}")
+    for flag, value in zip(tokens[::2], tokens[1::2]):
+        if not flag.startswith("--"):
+            raise ValueError(f"expected --FIELD VALUE, got {flag!r}")
+        name = flag[2:].replace("-", "_")
+        if name.endswith("_file") and name not in fields:  # --body-file mail.txt: the body, read from the file
+            name, value = name[:-5], pathlib.Path(value).read_text()
+        kind = fields.get(name, {}).get("type")
+        if kind in ("people", "list") and not value.lstrip().startswith("["):
+            item[name] = [v.strip() for v in value.split(",") if v.strip()]
+        elif kind in ("people", "list", "object") or value.lstrip()[:1] in ("[", "{") and kind is None:
+            item[name] = json.loads(value)
+        else:
+            item[name] = value
+    return item
+
+
+# ------------------------------------------------------------------ tests
+def cmd_task(a) -> int:
+    client = Client()
+    if a.what == "ls":
+        return cmd_tests(argparse.Namespace(project=a.env))
+    if a.what == "recheck":
+        ids = client.recheck(a.env, a.tasks or None)
+        print(f"Re-checking {len(ids)} test(s): {' '.join(ids)}" if ids else "No test needs a re-check.")
+        return 0
+    if a.what == "faults":
+        _table([(f["id"], f["title"], "seen live" if f["observed"] else "carried over (未验证)")
+                for f in client.faults(a.env)])
+        return 0
+    faults = [f.strip() for f in (a.faults or "").split(",") if f.strip()] or None
+    if faults and a.random_faults is not None:
+        raise ValueError("give --faults or --random-faults, not both")
+    noise = None if a.random_faults is None else {} if a.random_faults < 0 else {"rate": a.random_faults}
+    requests: list = list(a.request or [])
+    if a.file:
+        requests += [r.strip() for r in pathlib.Path(a.file).read_text().split("\n\n") if r.strip()]
+    if a.suggest and requests:
+        raise ValueError("give requests (--request, --file) or --suggest N, not both")
+    if a.criteria:
+        if len(requests) != 1:
+            raise ValueError("--criteria goes with one request: give a single --request")
+        requests = [{"text": requests[0], "criteria": a.criteria}]
+    if a.suggest:
+        job = client.suggest_tests(a.env, a.suggest, a.focus, faults, "hard" if a.hard else "normal", noise=noise)
+    elif requests:
+        job = client.write_tests(a.env, requests, faults, noise=noise)
+    else:
+        raise ValueError("give the requests (--request \"…\", or --file), or --suggest N")
+    print(job["id"], flush=True)
+    if a.no_wait:
+        return 0
+    job = _follow_job(client, a.env, job["id"])
+    for item in job["items"]:
+        if item["status"] == "ready":
+            print(f"{item['test_id']}  kept      {item['title']}")
+        elif item["status"] == "rejected":
+            print(f"{'-':<9} not a test  {item.get('request') or item['title']}\n"
+                  f"{'':<11}why: {item.get('detail')}\n{'':<11}try: {item.get('suggestion')}")
+        else:
+            print(f"{'-':<9} dropped   {item['title']}: {item.get('detail')}")
+    return 0 if any(i["status"] == "ready" for i in job["items"]) else 1
+
+
+def _follow_job(client: Client, project: str, jid: str) -> dict:
+    said: dict[int, str] = {}
+    while True:
+        job = client.job(project, jid)
+        for i, item in enumerate(job["items"]):
+            if said.get(i) != item["status"]:
+                said[i] = item["status"]
+                print(f"  [{i + 1}/{len(job['items'])}] {item['status']}: {item['title']}", file=sys.stderr,
+                      flush=True)
+        if job["status"] != "running":
+            if job.get("error") and not job["items"]:
+                raise ValueError(job["error"])
+            return job
+        time.sleep(POLL)
+
+
+# ------------------------------------------------------------------ runs
+def cmd_run(a) -> int:
+    if not a.agent_command:
+        raise ValueError("give your agent's command after --, e.g. sw run t-1a2b3c --agent mine@1 -- python agent.py")
+    _runnable(a.agent_command)
+    client = Client()
+    run = client.start(a.task, agent=a.agent, project=a.env, timeout=a.timeout,
+                       meta={"command": " ".join(a.agent_command)[:200]})
+    print(f"sw: run {run.id} of {run.test} started: {run.url}", file=sys.stderr, flush=True)
+    try:
+        answer, code = _drive(run, a.agent_command)
+    except KeyboardInterrupt:
+        return 130
+    result = run.finish(answer)
+    _report(result, code, a.json)
+    return 0 if result.passed else 1
+
+
+def cmd_worker(a) -> int:
+    if not a.agent_command:
+        raise ValueError("give your agent's command after --, e.g. sw worker --agent mine@1 -- python agent.py")
+    _runnable(a.agent_command)
+    client = Client()
+    worker, host = f"w-{secrets.token_hex(6)}", socket.gethostname()
+    print(f"sw: {a.agent} on {host} is waiting for runs: press Run again on a run's page ({client.url}/#/runs). "
+          "Ctrl-C stops.", file=sys.stderr, flush=True)
+    away = False
+    try:
+        while True:
+            try:
+                run = client.next_run(worker, agent=a.agent, meta=_worker_meta(a.agent_command, host),
+                                      timeout=a.timeout)
+            except OSError as e:  # the studio is down or restarting: keep asking
+                if not away:
+                    said = e if isinstance(e, ConnectionError) else f"cannot reach {client.url} ({e})"
+                    print(f"sw: {said}; trying again", file=sys.stderr, flush=True)
+                away = True
+                time.sleep(AWAY)
+                continue
+            except StateWeaveError as e:
+                if e.status < 500:
+                    raise
+                time.sleep(AWAY)
+                continue
+            if away:
+                print("sw: reached the studio again", file=sys.stderr, flush=True)
+                away = False
+            if run is None:
+                continue
+            print(f"sw: run {run.id} of {run.test}: {run.url}", file=sys.stderr, flush=True)
+            answer, code = _drive(run, a.agent_command)
+            try:
+                result = run.finish(answer)
+            except RunEnded as e:  # cancelled on the page, or out of time, while the agent worked
+                print(f"sw: run {run.id} had ended ({(e.run or {}).get('status', 'ended')})", file=sys.stderr)
+                continue
+            _report(result, code, a.json)
+            if a.once:
+                return 0 if result.passed else 1
+    except KeyboardInterrupt:
+        return 130
+    finally:
+        try:
+            client.leave(worker)
+        except (StateWeaveError, OSError):
+            pass
+
+
+def _runnable(command: list[str]) -> None:
+    """Refuse, before a run starts, a command that cannot start: a run would be made only to be given up."""
+    if shutil.which(command[0]) is None:
+        raise ValueError(f"could not start {command[0]}: no such command, or not executable")
+
+
+def _drive(run, command: list[str]) -> tuple[object, int]:
+    """Run COMMAND, the agent, with `run` in its environment (above); returns the answer it wrote and its exit code.
+    Ctrl-C, or a command that does not start, gives the run up."""
+    with tempfile.TemporaryDirectory(prefix="sw-run-") as folder:
+        folder = pathlib.Path(folder)
+        (folder / "run.json").write_text(json.dumps(run.data, indent=1))
+        (folder / "mcp.json").write_text(json.dumps({"mcpServers": run.mcp_servers()}, indent=1))
+        answer_file = folder / "answer.json"
+        env = {**os.environ, "STATEWEAVE_RUN": run.id, "STATEWEAVE_PROMPT": run.prompt, "STATEWEAVE_KIND": run.kind,
+               "STATEWEAVE_ANSWER_FORMAT": run.answer_format, "STATEWEAVE_RUN_FILE": str(folder / "run.json"),
+               "STATEWEAVE_MCP_CONFIG": str(folder / "mcp.json"), "STATEWEAVE_ANSWER_FILE": str(answer_file)}
+        try:
+            code = subprocess.call(command, env=env)
+        except KeyboardInterrupt:
+            run.cancel()
+            print(f"sw: gave run {run.id} up", file=sys.stderr)
+            raise
+        except OSError as e:
+            run.cancel()
+            raise ValueError(f"could not start {command[0]}: {e.strerror or e}") from None
+        answer = None
+        if answer_file.exists():
+            text = answer_file.read_text().strip()
+            try:
+                answer = json.loads(text) if text else None
+            except ValueError:
+                answer = text  # plain text: handed in as a string
+    return answer, code
+
+
+def _report(result, code: int, as_json: bool) -> None:
+    if as_json:
+        print(json.dumps({**dataclasses.asdict(result), "agent_exit": code}, indent=2), flush=True)
+        return
+    print(f"{'passed' if result.passed else result.status}  {result.calls} calls  {result.url}")
+    for reason in result.reasons:
+        print(f"  {reason}")
+    if code:
+        print(f"  (your agent exited with {code})")
+    sys.stdout.flush()
+
+
+def _worker_meta(command: list[str], host: str) -> dict:
+    """What a worker's runs show with them: the command, this machine, and the commit of the git checkout it runs
+    in (with a note when it has changes not committed yet), so two versions of an agent can be told apart."""
+    meta = {"command": " ".join(command)[:200], "host": host}
+    try:
+        head = subprocess.run(["git", "rev-parse", "--short", "HEAD"], capture_output=True, text=True, timeout=5)
+        if head.returncode == 0:
+            changed = subprocess.run(["git", "status", "--porcelain", "--untracked-files=no"], capture_output=True,
+                                     text=True, timeout=5).stdout.strip()
+            meta["commit"] = head.stdout.strip() + (" + uncommitted changes" if changed else "")
+    except (OSError, subprocess.SubprocessError):
+        pass
+    return meta
+
+
+def cmd_mcp_config(a) -> int:
+    run = Client().run(a.run)
+    if run.status != "running":
+        raise ValueError(f"run {run.id} has ended ({run.status}): its apps are gone")
+    print(json.dumps({"mcpServers": run.mcp_servers()}, indent=2))
+    return 0
+
+
+def cmd_tests(a) -> int:
+    _table([(t["id"], t["kind"], ",".join(t["apps"]), t["title"]) for t in Client().tests(a.project)])
+    return 0
+
+
+def cmd_start(a) -> int:
+    print(json.dumps(Client().start(a.test, agent=a.agent, project=a.project, timeout=a.timeout).data, indent=2))
+    return 0
+
+
+def cmd_finish(a) -> int:
+    answer = json.loads(a.answer) if a.answer is not None else None
+    print(json.dumps(dataclasses.asdict(Client().run(a.run).finish(answer)), indent=2))
+    return 0
+
+
+def cmd_cancel(a) -> int:
+    print(json.dumps(dataclasses.asdict(Client().run(a.run).cancel()), indent=2))
+    return 0
+
+
+COMMANDS = {"login": cmd_login, "logout": cmd_logout, "whoami": cmd_whoami, "env": cmd_env, "data": cmd_data,
+            "task": cmd_task, "run": cmd_run, "worker": cmd_worker, "mcp-config": cmd_mcp_config, "tests": cmd_tests,
+            "start": cmd_start,
+            "finish": cmd_finish, "cancel": cmd_cancel}
+
+if __name__ == "__main__":
+    sys.exit(main())

stateweave/config.py

@@ -0,0 +1,45 @@
+"""Where `sw login` keeps the studio's address and your API key: ~/.config/stateweave/config.json (or
+$XDG_CONFIG_HOME/stateweave/config.json, or the file $STATEWEAVE_CONFIG names), readable by you alone.
+
+    {"url": "https://acme.stateweave.net", "api_key": "sw_…"}
+
+STATEWEAVE_URL and STATEWEAVE_API_KEY, when set, win over the file, and Client(url=..., api_key=...) over both."""
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+
+
+def path() -> pathlib.Path:
+    if os.environ.get("STATEWEAVE_CONFIG"):
+        return pathlib.Path(os.environ["STATEWEAVE_CONFIG"])
+    base = os.environ.get("XDG_CONFIG_HOME") or pathlib.Path.home() / ".config"
+    return pathlib.Path(base) / "stateweave" / "config.json"
+
+
+def load() -> dict:
+    try:
+        data = json.loads(path().read_text())
+    except (OSError, ValueError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def save(url: str, api_key: str) -> pathlib.Path:
+    p = path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    tmp = p.with_suffix(".tmp")
+    tmp.touch(mode=0o600)
+    tmp.chmod(0o600)  # before the key is in it
+    tmp.write_text(json.dumps({"url": url, "api_key": api_key}, indent=1) + "\n")
+    tmp.replace(p)
+    return p
+
+
+def clear() -> bool:
+    p = path()
+    if not p.exists():
+        return False
+    p.unlink()
+    return True

stateweave_sdk-0.3.0.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.5
+Name: stateweave-sdk
+Version: 0.3.0
+Summary: Run your own AI agent on StateWeave: environments, tests, data of your own, and graded runs
+Project-URL: Homepage, https://stateweave.net
+Project-URL: Documentation, https://stateweave.net/docs/
+Author-email: StateWeave <mikewei@stateweave.net>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: agent evaluation,ai agents,digital twin,mcp,salesforce,shopify,slack,testing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# stateweave-sdk
+
+Run your own AI agent on [StateWeave](https://stateweave.net). StateWeave gives you working copies of the apps your
+agent uses (Slack, Gmail, Google Calendar, Sheets and Drive, Salesforce, Shopify, Zendesk), filled with a company's
+data, and tests with answer keys.
+Your agent stays on your machine and connects to the apps over their real APIs or MCP. Every run is graded and shown,
+call by call, on your StateWeave page.
+
+```bash
+pip install stateweave-sdk
+```
+
+This installs the `sw` command and the `stateweave` Python module. It uses only the standard library and needs
+Python 3.10 or later. The full documentation is at [stateweave.net/docs](https://stateweave.net/docs/).
+
+## Five minutes
+
+```bash
+sw login --url https://<you>.app.stateweave.net       # asks for an API key: make one under Connect an agent
+sw env ls                                              # your scenarios
+sw task ls                                             # the tests you can run
+sw run t-3fa2c1 --agent my-agent@0.1 -- python my_agent.py
+```
+
+`sw run` starts a run, runs your command with the run in its environment, then grades it:
+
+| variable | what it holds |
+|---|---|
+| `STATEWEAVE_PROMPT` | what to ask your agent |
+| `STATEWEAVE_KIND` | `answer` (it finds something out) or `action` (it changes the apps) |
+| `STATEWEAVE_ANSWER_FORMAT` | for an answer task, the JSON value to answer with |
+| `STATEWEAVE_RUN_FILE` | the whole run as JSON: each app's `base_url`, `endpoints`, `credentials` and MCP server |
+| `STATEWEAVE_MCP_CONFIG` | `{"mcpServers": {...}}`, for any MCP client |
+| `STATEWEAVE_ANSWER_FILE` | where your agent writes its answer (JSON, or plain text); nothing for an action task |
+| `STATEWEAVE_RUN` | the run's id |
+
+The run is graded when your command exits, whatever its exit code. Ctrl-C gives the run up instead. `sw run` exits
+0 when the run passed.
+
+With Claude Code as the agent, on a test of Slack and Gmail:
+
+```bash
+sw run t-3fa2c1 --agent claude-code -- sh -c 'claude -p "$STATEWEAVE_PROMPT" \
+  --mcp-config "$STATEWEAVE_MCP_CONFIG" --strict-mcp-config --allowedTools "mcp__slack__*" "mcp__gmail__*"'
+```
+
+In print mode Claude Code refuses any tool nobody approved, so `--allowedTools` must name each app the test uses.
+`--strict-mcp-config` keeps your own MCP servers out of the run. The
+[MCP servers](https://stateweave.net/docs/mcp.html#claude-code) page has a script that works out the apps by itself
+and hands in the answer for answer tasks.
+
+Give each version of your agent its own `--agent` label. The Runs page compares the labels.
+
+## Your own scenarios, tests and data
+
+```bash
+sw env new --apps gmail,zendesk --describe "A 40-person logistics software company after a carrier outage"
+sw task new p-9c41d2 --request "Which enterprise customers were hit by last week's outage?"
+sw task new p-9c41d2 --request "Refund #1042." --criteria "Only order #1042 is refunded, in full."
+sw task new p-9c41d2 --suggest 5 --focus "refunds promised but never processed" --random-faults
+sw task faults p-9c41d2
+sw data kinds p-9c41d2
+sw data add p-9c41d2 gmail email --from dana@northwind.example --subject "Credit?" --body-file mail.txt
+sw task recheck p-9c41d2
+```
+
+- **Your own requests.** A request you write is kept word for word. StateWeave builds its answer key and checker,
+  or tells you why the request can't be a test as written and suggests a rewording. `--criteria` says, in your words,
+  what a right outcome must meet.
+- **Faults.** Tests can inject the failures real APIs have: presets (`--faults`, listed by `sw task faults`) or
+  random ones (`--random-faults`).
+- **Your own data.** Added data joins the app's data as if the scenario had generated it. Only the scenario's
+  people and contacts may appear in it.
+- **Re-checking.** After you add data, that app's tests need a re-check before they run again.
+
+## In Python
+
+```python
+import stateweave
+
+with stateweave.start("t-3fa2c1", agent="my-agent@0.1") as run:
+    answer = my_agent(run.prompt, run.apps)     # run.apps: each app's URLs, credentials and MCP server
+    result = run.finish(answer)
+print(result.passed, result.reasons, result.url)
+```
+
+`stateweave.Client` also has `projects()`, `create_project()`, `data()`, `add_data()`, `write_tests()`,
+`suggest_tests()`, `faults()`, `fault_targets()`, `job()` and `recheck()`.
+
+## Where the address and key come from
+
+The first of these that is set wins:
+
+1. `Client(url=..., api_key=...)`
+2. `STATEWEAVE_URL` and `STATEWEAVE_API_KEY`
+3. What `sw login` kept in `~/.config/stateweave/config.json`, which only you can read
+
+To forget it: `sw logout`.

stateweave_sdk-0.3.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+stateweave/__init__.py,sha256=WyN3WKZrAoUsfRBfyABWVfjtDTFubl2htcZWd_bCfew,16376
+stateweave/__main__.py,sha256=VMjGazWFPuZs3O8nVKiKtqkI5kxDLkn85VcybEciH0k,26089
+stateweave/config.py,sha256=-N2lBXvAzsKExRnqUDPqbCQrcKL4JlrB7KUApnapXrU,1362
+stateweave_sdk-0.3.0.dist-info/METADATA,sha256=QNZh9r7KoXt3kd_gj1dIK4jUt3Vl-QjnasR825-zQKs,5622
+stateweave_sdk-0.3.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+stateweave_sdk-0.3.0.dist-info/entry_points.txt,sha256=tI-nhocURnnberY4NPY5g4YWBH0Uzm3xyRc_UH3osOo,48
+stateweave_sdk-0.3.0.dist-info/licenses/LICENSE,sha256=MoaPew_bCDvTLu9xHBnheNth1s8ZXqSS6czkUPvCvpo,11341
+stateweave_sdk-0.3.0.dist-info/RECORD,,

stateweave_sdk-0.3.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

stateweave_sdk-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sw = stateweave.__main__:main

stateweave_sdk-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 StateWeave
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.