spatialagents 0.1.0__py3-none-any.whl

spatialagents/trace.py

@@ -0,0 +1,237 @@
+"""The local trace: what the harness did, call by call.
+
+One SQLite file at a path the product chooses (Plexora's
+`<data_root>/.agent/ai/trace.sqlite`, SCIMAP Pro's
+`<configDir>/ai-cache/trace.sqlite`). Local and complete -- packet ids,
+tokens, cache verdicts, credit, latency -- and linked to the gateway's
+metadata row only by `gateway_request_id`. No prompt, image or answer text is
+written here either; those stay in the session store the engine already keeps.
+Request ids, never headers: the gateway token lives only in the token source.
+
+`NullTrace` is the trace of a runner that was given none: it records nothing.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+import time
+from pathlib import Path
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS runs (
+  run_id TEXT PRIMARY KEY, kind TEXT NOT NULL, project TEXT, session_id TEXT, gateway_run_id TEXT,
+  capability TEXT, billing TEXT, status TEXT NOT NULL, started_at REAL NOT NULL, finished_at REAL,
+  summary_json TEXT);
+CREATE TABLE IF NOT EXISTS model_calls (
+  id INTEGER PRIMARY KEY AUTOINCREMENT, run_id TEXT NOT NULL, worker INTEGER NOT NULL, seq INTEGER NOT NULL,
+  packet_id TEXT, kind TEXT, capability TEXT, prefix_fp TEXT, verdict TEXT,
+  input_uncached INTEGER, cache_read INTEGER, cache_write INTEGER, output_tokens INTEGER,
+  price_micro INTEGER, charged_micro INTEGER, cost_micro INTEGER, gateway_request_id TEXT,
+  latency_ms INTEGER, valid INTEGER, at REAL NOT NULL, task TEXT, model TEXT, provider TEXT,
+  attempts INTEGER, problem TEXT);
+CREATE INDEX IF NOT EXISTS model_calls_run ON model_calls(run_id, id);
+CREATE TABLE IF NOT EXISTS tool_calls (
+  id INTEGER PRIMARY KEY AUTOINCREMENT, run_id TEXT NOT NULL, agent TEXT, tool TEXT NOT NULL,
+  capability TEXT, permission TEXT, source TEXT NOT NULL, ok INTEGER, offloaded INTEGER,
+  operation_id TEXT, latency_ms INTEGER, at REAL NOT NULL);
+CREATE INDEX IF NOT EXISTS tool_calls_run ON tool_calls(run_id, id);
+CREATE TABLE IF NOT EXISTS tasks (
+  run_id TEXT NOT NULL, task_id TEXT NOT NULL, parent TEXT, label TEXT, state TEXT NOT NULL,
+  started_at REAL, finished_at REAL, detail_json TEXT, PRIMARY KEY (run_id, task_id));
+"""
+
+
+#: model_calls columns added after the table first shipped: the task and what
+#: served it; the tries the gateway client made, and why an answer was refused.
+LATE_COLUMNS = {"task": "TEXT", "model": "TEXT", "provider": "TEXT", "attempts": "INTEGER", "problem": "TEXT"}
+
+
+class TraceStore:
+    def __init__(self, path: Path | str):
+        self.path = Path(path)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.Lock()
+        with self._connect() as db:
+            db.executescript(SCHEMA)
+            # A trace written before these columns: CREATE IF NOT EXISTS never adds them.
+            have = {row[1] for row in db.execute("PRAGMA table_info(model_calls)")}
+            for column, kind in LATE_COLUMNS.items():
+                if column not in have:
+                    try:
+                        db.execute(f"ALTER TABLE model_calls ADD COLUMN {column} {kind}")
+                    except sqlite3.OperationalError:
+                        pass            # another process added it first
+
+    def _connect(self):
+        db = sqlite3.connect(self.path, timeout=30)
+        db.row_factory = sqlite3.Row
+        return db
+
+    def _write(self, sql: str, params=()):
+        with self._lock, self._connect() as db:
+            db.execute(sql, params)
+
+    def start_run(self, run_id: str, kind: str, **fields) -> None:
+        self._write("INSERT OR REPLACE INTO runs (run_id, kind, project, session_id, gateway_run_id, capability, "
+                    "billing, status, started_at) VALUES (?, ?, ?, ?, ?, ?, ?, 'running', ?)",
+                    (run_id, kind, fields.get("project"), fields.get("session_id"), fields.get("gateway_run_id"),
+                     fields.get("capability"), fields.get("billing"), time.time()))
+
+    def update_run(self, run_id: str, **fields) -> None:
+        if "summary" in fields:
+            fields["summary_json"] = json.dumps(fields.pop("summary"), default=str)
+        if not fields:
+            return
+        names = ", ".join(f"{name} = ?" for name in fields)
+        self._write(f"UPDATE runs SET {names} WHERE run_id = ?", (*fields.values(), run_id))
+
+    def finish_run(self, run_id: str, status: str, summary: dict) -> None:
+        self.update_run(run_id, status=status, finished_at=time.time(), summary=summary)
+
+    def call(self, run_id: str, **f) -> None:
+        self._write(
+            "INSERT INTO model_calls (run_id, worker, seq, packet_id, kind, capability, prefix_fp, verdict, "
+            "input_uncached, cache_read, cache_write, output_tokens, price_micro, charged_micro, cost_micro, "
+            "gateway_request_id, latency_ms, valid, at, task, model, provider, attempts, problem) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (run_id, f.get("worker", 0), f.get("seq", 0), f.get("packet_id"), f.get("kind"), f.get("capability"),
+             f.get("prefix_fp"), f.get("verdict"), f.get("input_uncached", 0), f.get("cache_read", 0),
+             f.get("cache_write", 0), f.get("output_tokens", 0), f.get("price_micro", 0), f.get("charged_micro", 0),
+             f.get("cost_micro"), f.get("gateway_request_id"), f.get("latency_ms", 0),
+             None if f.get("valid") is None else int(bool(f.get("valid"))), time.time(), f.get("task"),
+             f.get("model"), f.get("provider"), f.get("attempts"), f.get("problem")))
+
+    def tool_call(self, run_id: str, **f) -> None:
+        """One tool call of a conversation. `source` is `live`, `cache` (the
+        tool-result cache answered), `local` (a harness tool) or `declined`."""
+        self._write(
+            "INSERT INTO tool_calls (run_id, agent, tool, capability, permission, source, ok, offloaded, "
+            "operation_id, latency_ms, at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (run_id, f.get("agent"), f.get("tool"), f.get("capability"), f.get("permission"),
+             f.get("source", "live"), None if f.get("ok") is None else int(bool(f.get("ok"))),
+             int(bool(f.get("offloaded"))), f.get("operation_id"), f.get("latency_ms", 0), time.time()))
+
+    def tool_calls(self, run_id: str) -> list[dict]:
+        with self._connect() as db:
+            return [dict(r) for r in db.execute("SELECT * FROM tool_calls WHERE run_id = ? ORDER BY id",
+                                                (run_id,))]
+
+    def task(self, run_id: str, task_id: str, state: str, **f) -> None:
+        now = time.time()
+        with self._lock, self._connect() as db:
+            db.execute(
+                "INSERT INTO tasks (run_id, task_id, parent, label, state, started_at, detail_json) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(run_id, task_id) DO UPDATE SET state = excluded.state, "
+                "finished_at = CASE WHEN excluded.state IN ('done', 'failed', 'cancelled', 'skipped') THEN ? "
+                "ELSE finished_at END, detail_json = COALESCE(excluded.detail_json, detail_json)",
+                (run_id, task_id, f.get("parent"), f.get("label"), state, now,
+                 json.dumps(f["detail"], default=str) if f.get("detail") is not None else None, now))
+
+    # -- reading ---------------------------------------------------------------
+
+    def runs(self, limit: int = 20) -> list[dict]:
+        with self._connect() as db:
+            return [dict(r) for r in db.execute("SELECT * FROM runs ORDER BY started_at DESC LIMIT ?", (limit,))]
+
+    def run(self, run_id: str) -> dict | None:
+        with self._connect() as db:
+            row = db.execute("SELECT * FROM runs WHERE run_id = ? OR run_id LIKE ? ORDER BY started_at DESC",
+                             (run_id, f"{run_id}%")).fetchone()
+            return dict(row) if row else None
+
+    def calls(self, run_id: str) -> list[dict]:
+        with self._connect() as db:
+            return [dict(r) for r in db.execute("SELECT * FROM model_calls WHERE run_id = ? ORDER BY id", (run_id,))]
+
+    def tasks(self, run_id: str) -> list[dict]:
+        with self._connect() as db:
+            return [dict(r) for r in db.execute("SELECT * FROM tasks WHERE run_id = ? ORDER BY started_at",
+                                                (run_id,))]
+
+    def cache_report(self, run_id: str) -> dict:
+        """A run's cache and cost picture. `cache_read_share` is what the hit
+        rate says; `fresh_share` is the rest (uncached input and cache writes),
+        which is what costs: a run can read 60% and still spend most of its
+        money writing. Cost per packet counts repairs and retries in."""
+        calls = self.calls(run_id)
+
+        def tally(rows):
+            read = sum(c["cache_read"] or 0 for c in rows)
+            total = sum((c["input_uncached"] or 0) + (c["cache_read"] or 0) + (c["cache_write"] or 0) for c in rows)
+            return read, total
+
+        read, total = tally(calls)
+        verdicts: dict = {}
+        for c in calls:
+            verdicts[c["verdict"]] = verdicts.get(c["verdict"], 0) + 1
+        workers = len({c["worker"] for c in calls})
+        packets = len({c["packet_id"] for c in calls if c["packet_id"] and c["packet_id"] != "context"})
+        charged = sum(c["charged_micro"] or 0 for c in calls)
+        by_task: dict = {}
+        for task in dict.fromkeys(c.get("task") or "-" for c in calls):
+            rows = [c for c in calls if (c.get("task") or "-") == task]
+            r, t = tally(rows)
+            by_task[task] = {"calls": len(rows), "packets": len({c["packet_id"] for c in rows}),
+                             "charged_micro": sum(c["charged_micro"] or 0 for c in rows),
+                             "cache_read_share": round(r / t, 4) if t else 0.0}
+        tools = self.tool_calls(run_id)
+        return {"calls": len(calls), "workers": workers, "verdicts": verdicts,
+                "cache_read_share": round(read / total, 4) if total else 0.0,
+                "fresh_share": round((total - read) / total, 4) if total else 0.0,
+                "prefixes": sorted({c["prefix_fp"] for c in calls if c["prefix_fp"]}),
+                "input_tokens": total, "output_tokens": sum(c["output_tokens"] or 0 for c in calls),
+                "charged_micro": charged, "packets": packets,
+                "charged_per_packet_micro": round(charged / packets) if packets else 0,
+                "invalid_answers": sum(1 for c in calls if c["valid"] == 0),
+                "retries": sum(max(0, int(c.get("attempts") or 1) - 1) for c in calls),
+                "by_task": by_task,
+                "tool_latency": {"calls": len(tools),
+                                 "seconds": round(sum(t["latency_ms"] or 0 for t in tools) / 1000, 1)},
+                "tool_calls": self._tool_sources(run_id)}
+
+    def _tool_sources(self, run_id: str) -> dict:
+        out: dict = {}
+        for row in self.tool_calls(run_id):
+            out[row["source"]] = out.get(row["source"], 0) + 1
+        return out
+
+
+class NullTrace:
+    """A trace that records nothing: what a runner uses when it is given none."""
+
+    path = None
+
+    def start_run(self, run_id: str, kind: str, **fields) -> None:
+        pass
+
+    def update_run(self, run_id: str, **fields) -> None:
+        pass
+
+    def finish_run(self, run_id: str, status: str, summary: dict) -> None:
+        pass
+
+    def call(self, run_id: str, **f) -> None:
+        pass
+
+    def tool_call(self, run_id: str, **f) -> None:
+        pass
+
+    def task(self, run_id: str, task_id: str, state: str, **f) -> None:
+        pass
+
+    def tool_calls(self, run_id: str) -> list[dict]:
+        return []
+
+    def runs(self, limit: int = 20) -> list[dict]:
+        return []
+
+    def run(self, run_id: str) -> dict | None:
+        return None
+
+    def calls(self, run_id: str) -> list[dict]:
+        return []
+
+    def tasks(self, run_id: str) -> list[dict]:
+        return []

spatialagents/wire.py

@@ -0,0 +1,194 @@
+"""The harness's side of the gateway wire: the envelope it sends, what comes
+back, the canonical JSON every cached byte is built from, and how a task is
+named on the wire."""
+
+from __future__ import annotations
+
+import base64
+import json
+import re
+from dataclasses import dataclass, field
+
+#: A task inside a product: `module.task`, lower snake case (`chat.turn`, `gating.planning`).
+TASK_ID = re.compile(r"^[a-z][a-z0-9_]{0,31}\.[a-z][a-z0-9_]{0,31}$")
+#: A task on the wire: `<product>.<module>.<task>` (the gateway's WIRE_TASK).
+WIRE_TASK = re.compile(r"^[a-z][a-z0-9_]{1,31}\.[a-z][a-z0-9_]{0,31}\.[a-z][a-z0-9_]{0,31}$")
+#: A module name, which a call whose task no registry maps is filed under.
+MODULE = re.compile(r"^[a-z][a-z0-9_]{0,31}$")
+#: What a call whose kind no task maps is sent as, under its module.
+FALLBACK_TASK = "default"
+#: The module a call that names neither a task nor a module is filed under.
+FALLBACK_MODULE = "app"
+
+
+def task_id(product: str, task: str | None, *, module: str | None = None) -> str:
+    """`chat.turn` as the gateway knows it for `product`: `<product>.chat.turn`.
+
+    One gateway serves every BioCognia product and routes by the longest
+    match (`plexora.gating.*`, `plexora.*`, `*`), so every task on the wire
+    carries its product. A task already in wire form for this product is sent
+    as it is. None (a packet kind no task maps) is `<product>.<module>.default`;
+    the gateway serves an unknown task at the product's default and records
+    it, so a product release never waits for a gateway deploy."""
+    if task and WIRE_TASK.match(task) and task.startswith(f"{product}."):
+        return task
+    if task and TASK_ID.match(task):
+        return f"{product}.{task}"
+    head = module if isinstance(module, str) and MODULE.match(module) else FALLBACK_MODULE
+    return f"{product}.{head}.{FALLBACK_TASK}"
+
+
+def canonical(value) -> str:
+    """Sorted keys, no whitespace: the same object always gives the same bytes,
+    which is what keeps a prompt-cache prefix warm across workers and sessions."""
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+
+
+def text_block(text: str, *, cache: bool = False) -> dict:
+    block = {"type": "text", "text": text}
+    if cache:
+        block["cache_control"] = {"type": "ephemeral"}
+    return block
+
+
+def with_breakpoints(messages: list, *, final: bool = False) -> list:
+    """The conversation as sent: the last block of the newest message, and of
+    the newest earlier user message, carry a cache breakpoint.
+
+    The system prompt carries the first breakpoint (prefix.py); these two make
+    each call read everything up to its previous turn from cache and write only
+    the new turn. Marking the previous turn as well means a call reads exactly
+    what the last one wrote, however many image blocks a packet adds (a
+    provider looks back only so far from a breakpoint). Three in all, under
+    Anthropic's four. A copy: the stored history is never marked, so its bytes
+    -- and a saved chat -- stay as they were.
+
+    `final`: no call will read past this one (its worker retires after it),
+    so the newest message is not marked -- writing it would cost a quarter
+    more than sending it uncached, for nothing."""
+    out = list(messages)
+    marks = [len(out) - 1] if out and not final else []
+    earlier = next((i for i in range(len(out) - 2, -1, -1) if out[i].get("role") == "user"), None)
+    if earlier is not None:
+        marks.append(earlier)
+    for i in marks:
+        content = out[i].get("content")
+        if not isinstance(content, list) or not content:
+            continue        # a plain string stays as it is: its bytes must not change
+        out[i] = {**out[i], "content": content[:-1] + [{**content[-1], "cache_control": {"type": "ephemeral"}}]}
+    return out
+
+
+def image_block(data: bytes, fmt: str = "webp") -> dict:
+    media = {"webp": "image/webp", "png": "image/png", "jpeg": "image/jpeg", "jpg": "image/jpeg"}
+    return {"type": "image", "source": {"type": "base64", "media_type": media.get(fmt, "image/png"),
+                                        "data": base64.b64encode(data).decode("ascii")}}
+
+
+@dataclass
+class Usage:
+    input_uncached: int = 0
+    cache_read: int = 0
+    cache_write_5m: int = 0
+    cache_write_1h: int = 0
+    output_tokens: int = 0
+
+    @classmethod
+    def of(cls, raw) -> "Usage":
+        raw = raw if isinstance(raw, dict) else {}
+        return cls(**{name: int(raw.get(name) or 0) for name in cls.__dataclass_fields__})
+
+    @property
+    def cache_write(self) -> int:
+        return self.cache_write_5m + self.cache_write_1h
+
+    @property
+    def input_total(self) -> int:
+        return self.input_uncached + self.cache_read + self.cache_write
+
+    def bte(self) -> float:
+        """Base-input-token equivalents (reads 0.1x, 5-minute writes 1.25x, 1-hour
+        writes 2x, output 5x): one number to compare runs by, whatever the model."""
+        return (self.input_uncached + 0.1 * self.cache_read + 1.25 * self.cache_write_5m
+                + 2 * self.cache_write_1h + 5 * self.output_tokens)
+
+
+@dataclass
+class ModelRequest:
+    #: The capability class the harness sizes the call by (images or not, judgement or routine).
+    #: Never sent: the gateway routes by `task` alone.
+    capability: str
+    system: list
+    messages: list
+    max_tokens: int = 4096
+    output_schema: dict | None = None
+    context: dict = field(default_factory=dict)
+    model: str | None = None          # dev route only
+    #: Tool definitions (chat mode); decision mode sends none.
+    tools: list | None = None
+    #: The task this call does, as the product names it (`chat.turn`, `gating.threshold_evaluation`):
+    #: the gateway serves each task with the model an administrator assigned to it. The gateway
+    #: client puts it on the wire as `<product>.<module>.<task>` (`GatewayClient.wire_task`); None
+    #: sends the module's `default` task (the module is `context["feature"]`), which the gateway
+    #: serves at the product's default and records.
+    task: str | None = None
+
+    def envelope(self, task: str | None = None) -> dict:
+        """The body `/v1/ai/messages` takes. `task` is the wire id the client
+        resolved for this request (`GatewayClient.wire_task`); without one the
+        request's own `task` is sent as it is."""
+        request = {"system": self.system, "messages": self.messages, "max_tokens": self.max_tokens}
+        if self.tools:
+            request["tools"] = self.tools
+        if self.output_schema is not None:
+            request["output_schema"] = self.output_schema
+        body = {"task": task if task is not None else self.task, "context": self.context,
+                "request": request}
+        if self.model:
+            body["model"] = self.model
+        return body
+
+
+@dataclass
+class ModelResponse:
+    text: str
+    stop_reason: str | None
+    usage: Usage
+    gateway_request_id: str | None = None
+    status: str = "ok"
+    price_micro: int = 0
+    charged_micro: int = 0
+    cost_micro: int | None = None
+    billing: str = "credits"
+    #: The approved model that served the call, and through which provider: the gateway's names, which
+    #: the harness never chooses or interprets.
+    model: str | None = None
+    provider: str | None = None
+    balance: dict = field(default_factory=dict)
+    run: dict | None = None
+    latency_ms: int = 0
+    #: Tries the gateway client made for this answer (1: first time).
+    attempts: int = 1
+    #: The answer's content blocks in order: `text` and `tool_use` (with its
+    #: parsed `input`). Thinking blocks are not kept: the gateway accepts only
+    #: text, image, tool_use and tool_result blocks back.
+    blocks: list = field(default_factory=list)
+
+    @property
+    def tool_uses(self) -> list:
+        return [b for b in self.blocks if b.get("type") == "tool_use"]
+
+    def json(self):
+        """The answer as JSON: the whole text, or the first object in it.
+
+        Weaker models wrap the object in a code fence or prose, and reasoning
+        models put `<think>...</think>` first; both are stripped here and the
+        answer is still validated against its model afterwards."""
+        text = re.sub(r"<think>.*?</think>", "", self.text, flags=re.S).strip()
+        try:
+            return json.loads(text)
+        except ValueError:
+            start, end = text.find("{"), text.rfind("}")
+            if start >= 0 and end > start:
+                return json.loads(text[start:end + 1])
+            raise

spatialagents-0.1.0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.5
+Name: spatialagents
+Version: 0.1.0
+Summary: The chat harness runtime SCIMAP Pro, Plexora and other BioCognia products share
+Author-email: Ajit Johnson Nirmal <ajitjohnson.n@gmail.com>
+License-Expression: LicenseRef-Proprietary
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.12
+Requires-Dist: biocognia<0.2,>=0.1.1
+Requires-Dist: pydantic>=2.13
+Requires-Dist: pyyaml>=6
+Description-Content-Type: text/markdown
+
+# spatialagents
+
+The in-app AI conversation runtime BioCognia's products share (Plexora, SCIMAP
+Pro): the streamed model call through the BioCognia AI gateway, a tool loop
+with deferred tool schemas, approvals for source-file writes and deletes,
+sub-agents, deterministic compaction, a tool-result cache, offloaded results,
+the conversation store, the local trace and a terminal loop.
+
+A product binds it with three things and never the other way round:
+
+- a `spatialagents.backend.ToolBackend`: what its tools are and how one runs
+  (`catalog`, `definition`, `permission(tool, arguments)`, `invoke`, ...);
+- a `spatialagents.runner.ChatProfile`: its prompt content, task names and
+  wording;
+- its places on disk and its version, given to each store.
+
+```python
+from biocognia.gateway import TokenSource
+from spatialagents.conversations import ChatService, ConversationStore
+from spatialagents.gateway import GatewayClient
+from spatialagents.policy import Policy
+
+service = ChatService(ConversationStore(root / "conversations"),
+                      gateway_factory=lambda: GatewayClient(TokenSource(LICENSING)),
+                      backend_factory=MyBackend, profile=MY_PROFILE)
+started = service.start(Policy())
+```
+
+Dependencies: the standard library, `biocognia`, `pydantic`, `pyyaml`. No
+`mcp`, `anndata`, Flask or numpy, and nothing from either product;
+`import spatialagents` imports nothing beyond the standard library.
+
+Tests need no product, no network and no model: `spatialagents.testing` has
+`FakeGateway` (the gateway's wire and a prompt-cache emulator),
+`FakeToolBackend` and `ScriptedBrain`, and registers inert pytest fixtures.
+
+```bash
+UV_PROJECT_ENVIRONMENT=$HOME/.venvs/spatialagents uv sync --all-groups
+BIOCOGNIA_OFFLINE=1 $HOME/.venvs/spatialagents/bin/python -m pytest -q -p no:cacheprovider
+```

spatialagents-0.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+spatialagents/__init__.py,sha256=Gn7K_P5jBQs4ue2jBBtFv22Oh1Ww9UG3hVCqnWIzTBE,3281
+spatialagents/approvals.py,sha256=b6DfuJwhWpKJLDyVGuLFcwCGdGYQ7mM5NFB7UaWHFag,6815
+spatialagents/backend.py,sha256=ycesmKTGEDx_S112dJizSs6R-36ta9Un9ZrysYvEFNs,8911
+spatialagents/cache_plan.py,sha256=2YeWGe5F-nWvzLyAX6tuEE4azdoatU6nk9NnycmVjiY,5603
+spatialagents/conversations.py,sha256=qSe-SlcQjOZvYtI5MJL8xL_9gWIfcfbNTSRIkqGLhss,14670
+spatialagents/errors.py,sha256=nNPNTJmXWESdd74hROeQIlPgUWchrowslGutLdc2XsM,2669
+spatialagents/gateway.py,sha256=1FLPn4-uizgI6jMeCRP6O97SuOpsRMuoVhf96OfiLS8,10300
+spatialagents/offload.py,sha256=VknYLkAlQO4Z4NwXdVKKNO43ej198m7KsZpLTlHP1EI,4016
+spatialagents/orchestrator.py,sha256=dIIdqWKzHd_pOLvH2LpkypbOqVj80vWIq3GfTU1hEkY,11429
+spatialagents/plans.py,sha256=CWHJfDY2d-pdfqqwldSg_TUtGpIec3m9hRUTob57olY,39330
+spatialagents/policy.py,sha256=bgxHvQbqbV2t4uUfkvhEycak3mp0NUTH95Bihn5SeYU,5543
+spatialagents/prefix.py,sha256=yTpg9464oIJ3jjD_IxT2qztonErwpa9mM_6HbX-9CTo,4176
+spatialagents/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spatialagents/runner.py,sha256=-EKr5sPnfb17o7pb-QHQ3SQCFA0YdJh69zDar4kdeEk,41811
+spatialagents/schema.py,sha256=w6hpZxk7nA5RpivwRkWRTyWRTc_ecZ6aEX-UWgR4lxc,7252
+spatialagents/serialize.py,sha256=QyrzF3vJUOcA7wSbvoZUAX4gnFC33VXdgnvtdccEXgQ,3128
+spatialagents/sessions.py,sha256=WT_x9XClxOqmjnT8iWyr-QpcgdDvskV2yfLLi4fDd6g,10897
+spatialagents/testing.py,sha256=g2Uway5rSRG9qR9fN-XnXU2Z6vCYSh1IcbkHI5y40WE,46251
+spatialagents/toolcache.py,sha256=kfCRi6hft6HxXiTVAaxDd3dPQfZlxaNGjQLALXbZaho,5503
+spatialagents/tools.py,sha256=Itco43Lr0geYRMBWB6EMJTCfk1aX7IJHwcWyMgJ31Kk,23113
+spatialagents/trace.py,sha256=pbosKXXPAuknaFBCTXxpzAJZ8bhRH7q44FX07-7RbvY,12013
+spatialagents/wire.py,sha256=cA2IwXstMKpHTShaNV3TDvmnyDYQgSdE_luk--Ms1xY,8535
+spatialagents/chat/__init__.py,sha256=dBJ0Ec0xlFPEqg6jI0OB4N_OhI4jZ7mt4a_RfBi8nTw,584
+spatialagents/chat/cli.py,sha256=cC96RnVN1UaF9Rw3Lw-cXV1GQVASbx0e83jma7RL5xU,3747
+spatialagents/chat/http.py,sha256=v6Eg2liN_HA84KAPxjjA-2wOURIHR0weOMnKRJiJNG0,15083
+spatialagents/chat/server.py,sha256=ouV7vUQ9F5VS6guSc2AcCafUuQpsi8Q38r8yM9MCuyE,12721
+spatialagents/chat/static/chat.css,sha256=oM7OG0Ead7hcJvy4mmN-l9G_UZYzzl53tWg7ddQdQ_E,7410
+spatialagents/chat/static/chat.js,sha256=5C5daSjj9khK1F30a6j4nrhdtERhlJ4akEFLNsq5798,42545
+spatialagents/chat/static/index.html,sha256=kdLlCupv6N_XDwdiM03tXUIX1FD5HXTJOX5AoXdqacQ,595
+spatialagents-0.1.0.dist-info/METADATA,sha256=Wy83-s1JIGlDlm2j428PuTQBK3_6XtdHgjmtZOqWCjI,2391
+spatialagents-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+spatialagents-0.1.0.dist-info/entry_points.txt,sha256=q25HYrOGYjrqDHeZLWxUef4O-FmfMofpkE-4TrIhE9Q,49
+spatialagents-0.1.0.dist-info/RECORD,,

spatialagents-0.1.0.dist-info/WHEEL

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

spatialagents-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+spatialagents = spatialagents.testing