wspx 0.1.0.dev0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- wspx/__init__.py +24 -0
- wspx/_version.py +1 -0
- wspx/addressing.py +415 -0
- wspx/auth.py +77 -0
- wspx/cli/__init__.py +1 -0
- wspx/cli/client.py +124 -0
- wspx/cli/config.py +89 -0
- wspx/cli/connect.py +88 -0
- wspx/cli/main.py +848 -0
- wspx/cloud/__init__.py +20 -0
- wspx/cloud/app.py +191 -0
- wspx/cloud/backend.py +141 -0
- wspx/cloud/compose.py +85 -0
- wspx/cloud/deploy.py +102 -0
- wspx/config.py +189 -0
- wspx/control/__init__.py +5 -0
- wspx/control/app.py +488 -0
- wspx/control/backend.py +244 -0
- wspx/control/gateway_client.py +79 -0
- wspx/control/mcp_server.py +71 -0
- wspx/control/sessions.py +424 -0
- wspx/control/tracedb.py +183 -0
- wspx/control/ui/assets/index-BJFweZAn.css +1 -0
- wspx/control/ui/assets/index-DhUVhWIK.js +10 -0
- wspx/control/ui/index.html +13 -0
- wspx/control/views.py +180 -0
- wspx/diagnostics.py +146 -0
- wspx/driver/__init__.py +7 -0
- wspx/driver/loop.py +255 -0
- wspx/driver/messages.py +62 -0
- wspx/driver/providers/__init__.py +84 -0
- wspx/driver/providers/anthropic.py +149 -0
- wspx/driver/providers/compat.py +115 -0
- wspx/driver/providers/google.py +138 -0
- wspx/driver/providers/openai.py +125 -0
- wspx/driver/run.py +134 -0
- wspx/errors.py +69 -0
- wspx/gateway/__init__.py +8 -0
- wspx/gateway/app.py +626 -0
- wspx/gateway/ledger.py +536 -0
- wspx/gateway/prices.py +75 -0
- wspx/gateway/usage.py +284 -0
- wspx/handles.py +117 -0
- wspx/integrations/AGENTS.snippet.md +8 -0
- wspx/integrations/SKILL.md +52 -0
- wspx/integrations/__init__.py +17 -0
- wspx/integrations/claude-plugin/.claude-plugin/plugin.json +30 -0
- wspx/integrations/claude-plugin/skills/wspx/SKILL.md +52 -0
- wspx/integrations/codex-hooks.toml +9 -0
- wspx/lab/__init__.py +5 -0
- wspx/lab/analysis.py +485 -0
- wspx/lab/check.py +489 -0
- wspx/lab/evaluate.py +108 -0
- wspx/lab/export.py +275 -0
- wspx/lab/grep.py +754 -0
- wspx/lab/index.py +239 -0
- wspx/lab/ir/__init__.py +1 -0
- wspx/lab/ir/capture.py +299 -0
- wspx/lab/ir/graph.py +148 -0
- wspx/lab/ir/model_ir.py +522 -0
- wspx/lab/ir/semantics.py +1255 -0
- wspx/lab/ir/tape.py +853 -0
- wspx/lab/loader.py +204 -0
- wspx/lab/merge.py +200 -0
- wspx/lab/ops/__init__.py +76 -0
- wspx/lab/ops/builtin.py +379 -0
- wspx/lab/patch.py +320 -0
- wspx/lab/probe.py +206 -0
- wspx/lab/results.py +114 -0
- wspx/lab/sdk.py +120 -0
- wspx/lab/server.py +236 -0
- wspx/lab/session.py +1574 -0
- wspx/lab/tensors.py +119 -0
- wspx/lab/text.py +69 -0
- wspx/lab/tree.py +302 -0
- wspx/loops.py +127 -0
- wspx/project.py +143 -0
- wspx/py.typed +0 -0
- wspx/safety/__init__.py +15 -0
- wspx/safety/kill.py +47 -0
- wspx/safety/sweeper.py +68 -0
- wspx/store/__init__.py +64 -0
- wspx/store/objects.py +130 -0
- wspx/store/overlay.py +209 -0
- wspx/store/refs.py +150 -0
- wspx/testing/__init__.py +21 -0
- wspx/testing/api.py +155 -0
- wspx/testing/builtin.py +139 -0
- wspx/testing/runner.py +257 -0
- wspx/tools/__init__.py +17 -0
- wspx/tools/dispatch.py +129 -0
- wspx/tools/schemas.py +313 -0
- wspx/vcs/__init__.py +17 -0
- wspx/vcs/repo.py +431 -0
- wspx-0.1.0.dev0.dist-info/METADATA +278 -0
- wspx-0.1.0.dev0.dist-info/RECORD +99 -0
- wspx-0.1.0.dev0.dist-info/WHEEL +4 -0
- wspx-0.1.0.dev0.dist-info/entry_points.txt +10 -0
- wspx-0.1.0.dev0.dist-info/licenses/LICENSE +201 -0
wspx/__init__.py
ADDED
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
"""wspx: grep, edit, check, test and version-control model weights.
|
|
2
|
+
|
|
3
|
+
The top-level package is deliberately light: importing ``wspx`` never pulls in
|
|
4
|
+
torch or any provider SDK. The lab-side SDK loads on first use of
|
|
5
|
+
:func:`session`.
|
|
6
|
+
"""
|
|
7
|
+
|
|
8
|
+
from __future__ import annotations
|
|
9
|
+
|
|
10
|
+
from typing import TYPE_CHECKING, Any
|
|
11
|
+
|
|
12
|
+
from wspx._version import __version__
|
|
13
|
+
|
|
14
|
+
if TYPE_CHECKING:
|
|
15
|
+
from wspx.lab.session import Lab
|
|
16
|
+
|
|
17
|
+
__all__ = ["__version__", "session"]
|
|
18
|
+
|
|
19
|
+
|
|
20
|
+
def session(*args: Any, **kwargs: Any) -> Lab:
|
|
21
|
+
"""The live lab session (inside the lab), or a new local one (see :func:`wspx.lab.sdk.session`)."""
|
|
22
|
+
from wspx.lab.sdk import session as _session
|
|
23
|
+
|
|
24
|
+
return _session(*args, **kwargs)
|
wspx/_version.py
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
__version__ = "0.1.0.dev0"
|
wspx/addressing.py
ADDED
|
@@ -0,0 +1,415 @@
|
|
|
1
|
+
"""Addresses and handles (design §4.3).
|
|
2
|
+
|
|
3
|
+
An **address** names a slice of weights::
|
|
4
|
+
|
|
5
|
+
address := scope [ "[" slice "]" ]
|
|
6
|
+
scope := "L" layers "." role { "." sub } L19.mlp.down · L7.attn.q.h3 · L12.moe.e5.up
|
|
7
|
+
| "embed" | "unembed" | "final_norm" embed[" Wait"]
|
|
8
|
+
| raw parameter name model.layers.19.mlp.down_proj.weight[:, 11]
|
|
9
|
+
layers := N | N-M | "*"
|
|
10
|
+
|
|
11
|
+
A **handle** names an object that lives server-side::
|
|
12
|
+
|
|
13
|
+
handle := "@r" N [":" slug] @r1:writes-wait.mlp-down.top5
|
|
14
|
+
| "dir:" name ["(" provenance ")"] dir:loop(contrast.L19-resid.n200)
|
|
15
|
+
| "p_" id [":" slug] | "t_" id [":" slug]
|
|
16
|
+
| <commit-id> | HEAD~N | <branch>
|
|
17
|
+
|
|
18
|
+
Parsing is purely syntactic. Resolution against a model lives in the Model IR.
|
|
19
|
+
"""
|
|
20
|
+
|
|
21
|
+
from __future__ import annotations
|
|
22
|
+
|
|
23
|
+
import json
|
|
24
|
+
import re
|
|
25
|
+
from dataclasses import dataclass
|
|
26
|
+
from enum import StrEnum
|
|
27
|
+
|
|
28
|
+
from wspx.errors import AddressError, HandleError
|
|
29
|
+
|
|
30
|
+
SPECIAL_SCOPES = ("embed", "unembed", "final_norm")
|
|
31
|
+
|
|
32
|
+
_LAYERS_RE = re.compile(r"^L(\*|(\d+)(?:-(\d+))?)$")
|
|
33
|
+
_ROLE_PART_RE = re.compile(r"^[A-Za-z0-9_*?]+$")
|
|
34
|
+
_RAW_RE = re.compile(r"^[A-Za-z0-9_*?/:-]+(?:\.[A-Za-z0-9_*?/:-]+)*$")
|
|
35
|
+
_INT_RE = re.compile(r"^-?\d+$")
|
|
36
|
+
_AXIS_RE = re.compile(r"^[A-Za-z_]\w*$")
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
# --------------------------------------------------------------------------- layers
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
@dataclass(frozen=True, slots=True)
|
|
43
|
+
class LayerSel:
|
|
44
|
+
"""A selection of blocks: all (``*``), one (``N``) or an inclusive range (``N-M``)."""
|
|
45
|
+
|
|
46
|
+
start: int | None = None
|
|
47
|
+
stop: int | None = None
|
|
48
|
+
|
|
49
|
+
@classmethod
|
|
50
|
+
def all(cls) -> LayerSel:
|
|
51
|
+
return cls(None, None)
|
|
52
|
+
|
|
53
|
+
@property
|
|
54
|
+
def is_all(self) -> bool:
|
|
55
|
+
return self.start is None
|
|
56
|
+
|
|
57
|
+
def __contains__(self, index: object) -> bool:
|
|
58
|
+
if not isinstance(index, int):
|
|
59
|
+
return False
|
|
60
|
+
if self.start is None or self.stop is None:
|
|
61
|
+
return True
|
|
62
|
+
return self.start <= index <= self.stop
|
|
63
|
+
|
|
64
|
+
def __str__(self) -> str:
|
|
65
|
+
if self.start is None:
|
|
66
|
+
return "*"
|
|
67
|
+
if self.start == self.stop:
|
|
68
|
+
return str(self.start)
|
|
69
|
+
return f"{self.start}-{self.stop}"
|
|
70
|
+
|
|
71
|
+
|
|
72
|
+
# --------------------------------------------------------------------------- slices
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
@dataclass(frozen=True, slots=True)
|
|
76
|
+
class Index:
|
|
77
|
+
value: int
|
|
78
|
+
|
|
79
|
+
def __str__(self) -> str:
|
|
80
|
+
return str(self.value)
|
|
81
|
+
|
|
82
|
+
|
|
83
|
+
@dataclass(frozen=True, slots=True)
|
|
84
|
+
class Range:
|
|
85
|
+
start: int | None = None
|
|
86
|
+
stop: int | None = None
|
|
87
|
+
step: int | None = None
|
|
88
|
+
|
|
89
|
+
def to_slice(self) -> slice:
|
|
90
|
+
return slice(self.start, self.stop, self.step)
|
|
91
|
+
|
|
92
|
+
def __str__(self) -> str:
|
|
93
|
+
text = f"{_opt(self.start)}:{_opt(self.stop)}"
|
|
94
|
+
return f"{text}:{self.step}" if self.step is not None else text
|
|
95
|
+
|
|
96
|
+
|
|
97
|
+
@dataclass(frozen=True, slots=True)
|
|
98
|
+
class Token:
|
|
99
|
+
"""A vocabulary selector such as ``" Wait"`` (resolved through the tokenizer)."""
|
|
100
|
+
|
|
101
|
+
text: str
|
|
102
|
+
|
|
103
|
+
def __str__(self) -> str:
|
|
104
|
+
return json.dumps(self.text, ensure_ascii=False)
|
|
105
|
+
|
|
106
|
+
|
|
107
|
+
@dataclass(frozen=True, slots=True)
|
|
108
|
+
class Named:
|
|
109
|
+
"""A named-axis selector such as ``oc=12`` (convolution output channel)."""
|
|
110
|
+
|
|
111
|
+
axis: str
|
|
112
|
+
item: Index | Range
|
|
113
|
+
|
|
114
|
+
def __str__(self) -> str:
|
|
115
|
+
return f"{self.axis}={self.item}"
|
|
116
|
+
|
|
117
|
+
|
|
118
|
+
@dataclass(frozen=True, slots=True)
|
|
119
|
+
class HandleRef:
|
|
120
|
+
"""A result-set handle used as an index list, e.g. ``[:, @r1]``."""
|
|
121
|
+
|
|
122
|
+
handle: Handle
|
|
123
|
+
|
|
124
|
+
def __str__(self) -> str:
|
|
125
|
+
return str(self.handle)
|
|
126
|
+
|
|
127
|
+
|
|
128
|
+
SliceItem = Index | Range | Token | Named | HandleRef
|
|
129
|
+
|
|
130
|
+
|
|
131
|
+
def _opt(value: int | None) -> str:
|
|
132
|
+
return "" if value is None else str(value)
|
|
133
|
+
|
|
134
|
+
|
|
135
|
+
# --------------------------------------------------------------------------- address
|
|
136
|
+
|
|
137
|
+
|
|
138
|
+
class ScopeKind(StrEnum):
|
|
139
|
+
SHORT = "short"
|
|
140
|
+
SPECIAL = "special"
|
|
141
|
+
RAW = "raw"
|
|
142
|
+
|
|
143
|
+
|
|
144
|
+
@dataclass(frozen=True, slots=True)
|
|
145
|
+
class Address:
|
|
146
|
+
kind: ScopeKind
|
|
147
|
+
layers: LayerSel | None = None
|
|
148
|
+
"""Block selection; set only for short addresses."""
|
|
149
|
+
path: tuple[str, ...] = ()
|
|
150
|
+
"""Role path for short addresses (``("mlp", "down")``) or the special name."""
|
|
151
|
+
raw: str | None = None
|
|
152
|
+
"""Raw parameter name (may contain ``*`` globs)."""
|
|
153
|
+
slice: tuple[SliceItem, ...] | None = None
|
|
154
|
+
|
|
155
|
+
@property
|
|
156
|
+
def scope(self) -> str:
|
|
157
|
+
if self.kind is ScopeKind.SHORT:
|
|
158
|
+
return f"L{self.layers}." + ".".join(self.path)
|
|
159
|
+
if self.kind is ScopeKind.SPECIAL:
|
|
160
|
+
return self.path[0]
|
|
161
|
+
assert self.raw is not None
|
|
162
|
+
return self.raw
|
|
163
|
+
|
|
164
|
+
@property
|
|
165
|
+
def has_glob(self) -> bool:
|
|
166
|
+
if self.kind is ScopeKind.SHORT:
|
|
167
|
+
assert self.layers is not None
|
|
168
|
+
return self.layers.start != self.layers.stop or any(
|
|
169
|
+
"*" in p or "?" in p for p in self.path
|
|
170
|
+
)
|
|
171
|
+
return self.raw is not None and ("*" in self.raw or "?" in self.raw)
|
|
172
|
+
|
|
173
|
+
def with_slice(self, items: tuple[SliceItem, ...] | None) -> Address:
|
|
174
|
+
return Address(self.kind, self.layers, self.path, self.raw, items)
|
|
175
|
+
|
|
176
|
+
def __str__(self) -> str:
|
|
177
|
+
if self.slice is None:
|
|
178
|
+
return self.scope
|
|
179
|
+
return f"{self.scope}[{', '.join(str(i) for i in self.slice)}]"
|
|
180
|
+
|
|
181
|
+
|
|
182
|
+
def parse_address(text: str) -> Address:
|
|
183
|
+
"""Parse an address. Raises :class:`AddressError` with a pointer to the problem."""
|
|
184
|
+
if not isinstance(text, str) or not text.strip():
|
|
185
|
+
raise AddressError("empty address")
|
|
186
|
+
text = text.strip()
|
|
187
|
+
scope_text, slice_items = _split_slice(text)
|
|
188
|
+
if not scope_text:
|
|
189
|
+
raise AddressError(f"{text!r}: missing scope before '['")
|
|
190
|
+
|
|
191
|
+
head, _, rest = scope_text.partition(".")
|
|
192
|
+
layer_match = _LAYERS_RE.match(head)
|
|
193
|
+
if layer_match:
|
|
194
|
+
if not rest:
|
|
195
|
+
raise AddressError(f"{text!r}: a layer scope needs a role, e.g. {head}.mlp.down")
|
|
196
|
+
parts = tuple(rest.split("."))
|
|
197
|
+
for part in parts:
|
|
198
|
+
if not _ROLE_PART_RE.match(part):
|
|
199
|
+
raise AddressError(f"{text!r}: invalid role segment {part!r}")
|
|
200
|
+
return Address(ScopeKind.SHORT, _layer_sel(layer_match, text), parts, None, slice_items)
|
|
201
|
+
|
|
202
|
+
if scope_text in SPECIAL_SCOPES:
|
|
203
|
+
return Address(ScopeKind.SPECIAL, None, (scope_text,), None, slice_items)
|
|
204
|
+
|
|
205
|
+
if not _RAW_RE.match(scope_text):
|
|
206
|
+
raise AddressError(f"{text!r}: not a short address, special scope or parameter name")
|
|
207
|
+
return Address(ScopeKind.RAW, None, (), scope_text, slice_items)
|
|
208
|
+
|
|
209
|
+
|
|
210
|
+
def _layer_sel(match: re.Match[str], text: str) -> LayerSel:
|
|
211
|
+
if match.group(1) == "*":
|
|
212
|
+
return LayerSel.all()
|
|
213
|
+
start = int(match.group(2))
|
|
214
|
+
stop = int(match.group(3)) if match.group(3) is not None else start
|
|
215
|
+
if stop < start:
|
|
216
|
+
raise AddressError(f"{text!r}: layer range {start}-{stop} is reversed")
|
|
217
|
+
return LayerSel(start, stop)
|
|
218
|
+
|
|
219
|
+
|
|
220
|
+
def _split_slice(text: str) -> tuple[str, tuple[SliceItem, ...] | None]:
|
|
221
|
+
open_at = text.find("[")
|
|
222
|
+
if open_at < 0:
|
|
223
|
+
if "]" in text:
|
|
224
|
+
raise AddressError(f"{text!r}: unbalanced ']'")
|
|
225
|
+
return text, None
|
|
226
|
+
if not text.endswith("]"):
|
|
227
|
+
raise AddressError(f"{text!r}: slice must close with ']' at the end of the address")
|
|
228
|
+
body = text[open_at + 1 : -1]
|
|
229
|
+
return text[:open_at], tuple(_parse_slice_item(item, text) for item in _split_items(body, text))
|
|
230
|
+
|
|
231
|
+
|
|
232
|
+
def _split_items(body: str, text: str) -> list[str]:
|
|
233
|
+
"""Split a slice body on top-level commas, honouring quoted strings."""
|
|
234
|
+
items: list[str] = []
|
|
235
|
+
buf: list[str] = []
|
|
236
|
+
quote: str | None = None
|
|
237
|
+
escaped = False
|
|
238
|
+
for ch in body:
|
|
239
|
+
if quote:
|
|
240
|
+
buf.append(ch)
|
|
241
|
+
if escaped:
|
|
242
|
+
escaped = False
|
|
243
|
+
elif ch == "\\":
|
|
244
|
+
escaped = True
|
|
245
|
+
elif ch == quote:
|
|
246
|
+
quote = None
|
|
247
|
+
continue
|
|
248
|
+
if ch in "\"'":
|
|
249
|
+
quote = ch
|
|
250
|
+
buf.append(ch)
|
|
251
|
+
elif ch == ",":
|
|
252
|
+
items.append("".join(buf).strip())
|
|
253
|
+
buf = []
|
|
254
|
+
else:
|
|
255
|
+
buf.append(ch)
|
|
256
|
+
if quote:
|
|
257
|
+
raise AddressError(f"{text!r}: unterminated string in slice")
|
|
258
|
+
items.append("".join(buf).strip())
|
|
259
|
+
if any(not item for item in items):
|
|
260
|
+
raise AddressError(f"{text!r}: empty slice item")
|
|
261
|
+
return items
|
|
262
|
+
|
|
263
|
+
|
|
264
|
+
def _parse_slice_item(item: str, text: str) -> SliceItem:
|
|
265
|
+
if item[0] in "\"'":
|
|
266
|
+
return Token(_unquote(item, text))
|
|
267
|
+
if item.startswith("@"):
|
|
268
|
+
try:
|
|
269
|
+
return HandleRef(parse_handle(item, allow_revision=False))
|
|
270
|
+
except HandleError as exc:
|
|
271
|
+
raise AddressError(f"{text!r}: {exc}") from None
|
|
272
|
+
if "=" in item:
|
|
273
|
+
axis, _, value = item.partition("=")
|
|
274
|
+
axis = axis.strip()
|
|
275
|
+
if not _AXIS_RE.match(axis):
|
|
276
|
+
raise AddressError(f"{text!r}: invalid axis name {axis!r}")
|
|
277
|
+
inner = _parse_index_or_range(value.strip(), text)
|
|
278
|
+
return Named(axis, inner)
|
|
279
|
+
return _parse_index_or_range(item, text)
|
|
280
|
+
|
|
281
|
+
|
|
282
|
+
def _parse_index_or_range(item: str, text: str) -> Index | Range:
|
|
283
|
+
if _INT_RE.match(item):
|
|
284
|
+
return Index(int(item))
|
|
285
|
+
if ":" in item:
|
|
286
|
+
parts = [p.strip() for p in item.split(":")]
|
|
287
|
+
if len(parts) > 3:
|
|
288
|
+
raise AddressError(f"{text!r}: invalid range {item!r}")
|
|
289
|
+
values: list[int | None] = []
|
|
290
|
+
for part in parts:
|
|
291
|
+
if part == "":
|
|
292
|
+
values.append(None)
|
|
293
|
+
elif _INT_RE.match(part):
|
|
294
|
+
values.append(int(part))
|
|
295
|
+
else:
|
|
296
|
+
raise AddressError(f"{text!r}: invalid range bound {part!r}")
|
|
297
|
+
while len(values) < 3:
|
|
298
|
+
values.append(None)
|
|
299
|
+
if values[2] == 0:
|
|
300
|
+
raise AddressError(f"{text!r}: range step cannot be zero")
|
|
301
|
+
return Range(values[0], values[1], values[2])
|
|
302
|
+
raise AddressError(f"{text!r}: invalid slice item {item!r}")
|
|
303
|
+
|
|
304
|
+
|
|
305
|
+
def _unquote(item: str, text: str) -> str:
|
|
306
|
+
quote = item[0]
|
|
307
|
+
if len(item) < 2 or item[-1] != quote:
|
|
308
|
+
raise AddressError(f"{text!r}: malformed string {item!r}")
|
|
309
|
+
if quote == '"':
|
|
310
|
+
try:
|
|
311
|
+
value = json.loads(item)
|
|
312
|
+
except json.JSONDecodeError:
|
|
313
|
+
raise AddressError(f"{text!r}: malformed string {item!r}") from None
|
|
314
|
+
assert isinstance(value, str)
|
|
315
|
+
return value
|
|
316
|
+
inner = item[1:-1]
|
|
317
|
+
return re.sub(r"\\(.)", r"\1", inner)
|
|
318
|
+
|
|
319
|
+
|
|
320
|
+
# --------------------------------------------------------------------------- handles
|
|
321
|
+
|
|
322
|
+
|
|
323
|
+
class HandleKind(StrEnum):
|
|
324
|
+
RESULT = "result"
|
|
325
|
+
DIRECTION = "direction"
|
|
326
|
+
PATCH = "patch"
|
|
327
|
+
TRACE = "trace"
|
|
328
|
+
REVISION = "revision"
|
|
329
|
+
|
|
330
|
+
|
|
331
|
+
_SLUG = r"(?::([A-Za-z0-9_.\-]+))?"
|
|
332
|
+
_RESULT_RE = re.compile(rf"^@r(\d+){_SLUG}$")
|
|
333
|
+
_DIR_RE = re.compile(r"^dir:([A-Za-z_][\w\-]*)(?:\((.*)\))?$")
|
|
334
|
+
_PATCH_RE = re.compile(rf"^p_([0-9a-z]+){_SLUG}$")
|
|
335
|
+
_TRACE_RE = re.compile(rf"^t_([0-9a-z]+){_SLUG}$")
|
|
336
|
+
_REV_RE = re.compile(r"^(HEAD|[A-Za-z0-9][A-Za-z0-9._/\-]*)((?:~\d*|\^\d*)*)$")
|
|
337
|
+
|
|
338
|
+
|
|
339
|
+
@dataclass(frozen=True, slots=True)
|
|
340
|
+
class Handle:
|
|
341
|
+
kind: HandleKind
|
|
342
|
+
id: str
|
|
343
|
+
"""Authoritative key: ``r1``, ``loop``, ``p_8f2a``, ``t_1c0d`` or a revision expression."""
|
|
344
|
+
label: str | None = None
|
|
345
|
+
"""The slug, agent-given name or provenance carried alongside the id (advisory)."""
|
|
346
|
+
|
|
347
|
+
@property
|
|
348
|
+
def key(self) -> str:
|
|
349
|
+
"""The canonical lookup form, without the advisory label."""
|
|
350
|
+
if self.kind is HandleKind.RESULT:
|
|
351
|
+
return f"@{self.id}"
|
|
352
|
+
if self.kind is HandleKind.DIRECTION:
|
|
353
|
+
return f"dir:{self.id}"
|
|
354
|
+
return self.id
|
|
355
|
+
|
|
356
|
+
def __str__(self) -> str:
|
|
357
|
+
if self.label is None:
|
|
358
|
+
return self.key
|
|
359
|
+
if self.kind is HandleKind.DIRECTION:
|
|
360
|
+
return f"{self.key}({self.label})"
|
|
361
|
+
return f"{self.key}:{self.label}"
|
|
362
|
+
|
|
363
|
+
|
|
364
|
+
def parse_handle(text: str, *, allow_revision: bool = True) -> Handle:
|
|
365
|
+
if not isinstance(text, str) or not text.strip():
|
|
366
|
+
raise HandleError("empty handle")
|
|
367
|
+
text = text.strip()
|
|
368
|
+
if m := _RESULT_RE.match(text):
|
|
369
|
+
return Handle(HandleKind.RESULT, f"r{int(m.group(1))}", m.group(2))
|
|
370
|
+
if m := _DIR_RE.match(text):
|
|
371
|
+
return Handle(HandleKind.DIRECTION, m.group(1), m.group(2) or None)
|
|
372
|
+
if m := _PATCH_RE.match(text):
|
|
373
|
+
return Handle(HandleKind.PATCH, f"p_{m.group(1)}", m.group(2))
|
|
374
|
+
if m := _TRACE_RE.match(text):
|
|
375
|
+
return Handle(HandleKind.TRACE, f"t_{m.group(1)}", m.group(2))
|
|
376
|
+
if (
|
|
377
|
+
allow_revision
|
|
378
|
+
and _REV_RE.match(text)
|
|
379
|
+
and is_valid_ref_name(text.split("~")[0].split("^")[0])
|
|
380
|
+
):
|
|
381
|
+
return Handle(HandleKind.REVISION, text)
|
|
382
|
+
raise HandleError(
|
|
383
|
+
f"{text!r} is not a handle; expected @rN, dir:name, p_…, t_…, a commit or a branch"
|
|
384
|
+
)
|
|
385
|
+
|
|
386
|
+
|
|
387
|
+
def is_valid_ref_name(name: str) -> bool:
|
|
388
|
+
"""Git-compatible branch-name rules, slightly stricter."""
|
|
389
|
+
if not name or name.startswith(("/", ".", "-")) or name.endswith(("/", ".", ".lock")):
|
|
390
|
+
return False
|
|
391
|
+
if ".." in name or "//" in name or "@{" in name:
|
|
392
|
+
return False
|
|
393
|
+
return re.fullmatch(r"[A-Za-z0-9._/\-]+", name) is not None
|
|
394
|
+
|
|
395
|
+
|
|
396
|
+
_SLUG_CLEAN_RE = re.compile(r"[^a-z0-9]+")
|
|
397
|
+
|
|
398
|
+
|
|
399
|
+
def make_slug(*parts: object, max_len: int = 60) -> str:
|
|
400
|
+
"""Build a readable slug from the pieces that produced a handle.
|
|
401
|
+
|
|
402
|
+
>>> make_slug('writes(" Wait")', "L*.mlp.down", "top5")
|
|
403
|
+
'writes-wait.l-mlp-down.top5'
|
|
404
|
+
"""
|
|
405
|
+
cleaned = []
|
|
406
|
+
for part in parts:
|
|
407
|
+
if part is None:
|
|
408
|
+
continue
|
|
409
|
+
piece = _SLUG_CLEAN_RE.sub("-", str(part).lower()).strip("-")
|
|
410
|
+
if piece:
|
|
411
|
+
cleaned.append(piece)
|
|
412
|
+
slug = ".".join(cleaned)
|
|
413
|
+
if len(slug) > max_len:
|
|
414
|
+
slug = slug[:max_len].rstrip("-.")
|
|
415
|
+
return slug or "unnamed"
|
wspx/auth.py
ADDED
|
@@ -0,0 +1,77 @@
|
|
|
1
|
+
"""Signed tokens shared by the control plane and the gateway.
|
|
2
|
+
|
|
3
|
+
The control plane mints a short-lived *session token* for each driver runner.
|
|
4
|
+
The runner's SDK clients present it to the gateway in place of an API key;
|
|
5
|
+
the gateway verifies it with the shared secret and swaps in the real key.
|
|
6
|
+
Neither the runner nor the lab ever sees a provider key.
|
|
7
|
+
"""
|
|
8
|
+
|
|
9
|
+
from __future__ import annotations
|
|
10
|
+
|
|
11
|
+
import base64
|
|
12
|
+
import hashlib
|
|
13
|
+
import hmac
|
|
14
|
+
import json
|
|
15
|
+
import secrets
|
|
16
|
+
import time
|
|
17
|
+
from dataclasses import dataclass
|
|
18
|
+
|
|
19
|
+
from wspx.errors import WspxError
|
|
20
|
+
|
|
21
|
+
PREFIX = "wspx_s_"
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
class TokenError(WspxError):
|
|
25
|
+
"""A token is malformed, forged or expired."""
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
@dataclass(frozen=True)
|
|
29
|
+
class SessionClaims:
|
|
30
|
+
session: str
|
|
31
|
+
expires: float
|
|
32
|
+
scope: str = "llm"
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
def new_secret() -> str:
|
|
36
|
+
return secrets.token_urlsafe(32)
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
def _b64(data: bytes) -> str:
|
|
40
|
+
return base64.urlsafe_b64encode(data).rstrip(b"=").decode()
|
|
41
|
+
|
|
42
|
+
|
|
43
|
+
def _unb64(text: str) -> bytes:
|
|
44
|
+
return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4))
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
def mint(secret: str, session: str, *, ttl: float = 24 * 3600, scope: str = "llm") -> str:
|
|
48
|
+
body = _b64(
|
|
49
|
+
json.dumps(
|
|
50
|
+
{"sid": session, "exp": time.time() + ttl, "scope": scope}, sort_keys=True
|
|
51
|
+
).encode()
|
|
52
|
+
)
|
|
53
|
+
sig = _b64(hmac.new(secret.encode(), body.encode(), hashlib.sha256).digest())
|
|
54
|
+
return f"{PREFIX}{body}.{sig}"
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
def verify(secret: str, token: str, *, scope: str = "llm") -> SessionClaims:
|
|
58
|
+
if not token.startswith(PREFIX) or "." not in token:
|
|
59
|
+
raise TokenError("not a wspx session token")
|
|
60
|
+
body, _, sig = token[len(PREFIX) :].partition(".")
|
|
61
|
+
expected = _b64(hmac.new(secret.encode(), body.encode(), hashlib.sha256).digest())
|
|
62
|
+
if not hmac.compare_digest(sig, expected):
|
|
63
|
+
raise TokenError("bad token signature")
|
|
64
|
+
try:
|
|
65
|
+
data = json.loads(_unb64(body))
|
|
66
|
+
except (ValueError, json.JSONDecodeError):
|
|
67
|
+
raise TokenError("malformed token") from None
|
|
68
|
+
if data.get("scope") != scope:
|
|
69
|
+
raise TokenError(f"token scope {data.get('scope')!r} is not {scope!r}")
|
|
70
|
+
if data["exp"] < time.time():
|
|
71
|
+
raise TokenError("token expired")
|
|
72
|
+
return SessionClaims(data["sid"], float(data["exp"]), data["scope"])
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
def check_bearer(expected: str, presented: str | None) -> bool:
|
|
76
|
+
"""Constant-time comparison for static admin/API tokens."""
|
|
77
|
+
return bool(presented) and hmac.compare_digest(expected.encode(), (presented or "").encode())
|
wspx/cli/__init__.py
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
"""The ``wspx`` command line. Thin by design: no torch, no provider keys on disk."""
|
wspx/cli/client.py
ADDED
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
"""HTTP client for the control plane."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Iterator
|
|
6
|
+
from typing import Any
|
|
7
|
+
|
|
8
|
+
import httpx
|
|
9
|
+
|
|
10
|
+
from wspx.errors import WspxError
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
class Control:
|
|
14
|
+
def __init__(
|
|
15
|
+
self, url: str, token: str, *, transport: httpx.BaseTransport | None = None
|
|
16
|
+
) -> None:
|
|
17
|
+
self.url = url.rstrip("/")
|
|
18
|
+
self.token = token
|
|
19
|
+
self.client = httpx.Client(
|
|
20
|
+
base_url=self.url,
|
|
21
|
+
headers={"authorization": f"Bearer {token}"},
|
|
22
|
+
timeout=httpx.Timeout(3600.0, connect=15.0),
|
|
23
|
+
transport=transport,
|
|
24
|
+
)
|
|
25
|
+
|
|
26
|
+
def _req(self, method: str, path: str, **kw: Any) -> Any:
|
|
27
|
+
try:
|
|
28
|
+
r = self.client.request(method, path, **kw)
|
|
29
|
+
except httpx.HTTPError as exc:
|
|
30
|
+
raise WspxError(f"cannot reach the control plane at {self.url}: {exc}") from exc
|
|
31
|
+
if r.status_code >= 400:
|
|
32
|
+
try:
|
|
33
|
+
detail = r.json().get("detail", r.text)
|
|
34
|
+
except ValueError:
|
|
35
|
+
detail = r.text
|
|
36
|
+
raise WspxError(f"{method} {path}: {detail}")
|
|
37
|
+
return r.json()
|
|
38
|
+
|
|
39
|
+
def sessions(self) -> list[dict[str, Any]]:
|
|
40
|
+
data: list[dict[str, Any]] = self._req("GET", "/api/sessions")["sessions"]
|
|
41
|
+
return data
|
|
42
|
+
|
|
43
|
+
def upload_project(self, snapshot: bytes) -> str:
|
|
44
|
+
"""Store a packed project; returns its snapshot id (uploads are deduplicated by content)."""
|
|
45
|
+
data: dict[str, Any] = self._req(
|
|
46
|
+
"POST", "/api/projects", content=snapshot, headers={"content-type": "application/gzip"}
|
|
47
|
+
)
|
|
48
|
+
return str(data["snapshot"])
|
|
49
|
+
|
|
50
|
+
def new(self, **body: Any) -> dict[str, Any]:
|
|
51
|
+
data: dict[str, Any] = self._req("POST", "/api/sessions", json=body)
|
|
52
|
+
return data
|
|
53
|
+
|
|
54
|
+
def session(self, sid: str) -> dict[str, Any]:
|
|
55
|
+
data: dict[str, Any] = self._req("GET", f"/api/sessions/{sid}")
|
|
56
|
+
return data
|
|
57
|
+
|
|
58
|
+
def tool(self, sid: str, name: str, args: dict[str, Any]) -> dict[str, Any]:
|
|
59
|
+
data: dict[str, Any] = self._req(
|
|
60
|
+
"POST", f"/api/sessions/{sid}/tools/{name}", json={"args": args, "source": "human"}
|
|
61
|
+
)
|
|
62
|
+
return data
|
|
63
|
+
|
|
64
|
+
def action(self, sid: str, action: str, **body: Any) -> dict[str, Any]:
|
|
65
|
+
data: dict[str, Any] = self._req("POST", f"/api/sessions/{sid}/{action}", json=body)
|
|
66
|
+
return data
|
|
67
|
+
|
|
68
|
+
def keys(self) -> dict[str, Any]:
|
|
69
|
+
data: dict[str, Any] = self._req("GET", "/api/keys")["keys"]
|
|
70
|
+
return data
|
|
71
|
+
|
|
72
|
+
def reload_keys(self) -> bool:
|
|
73
|
+
return bool(self._req("POST", "/api/keys/reload")["reloaded"])
|
|
74
|
+
|
|
75
|
+
def limits(self) -> list[dict[str, Any]]:
|
|
76
|
+
data: list[dict[str, Any]] = self._req("GET", "/api/limits")["limits"]
|
|
77
|
+
return data
|
|
78
|
+
|
|
79
|
+
def set_limit(self, body: dict[str, Any]) -> dict[str, Any]:
|
|
80
|
+
data: dict[str, Any] = self._req("POST", "/api/limits", json=body)
|
|
81
|
+
return data
|
|
82
|
+
|
|
83
|
+
def remove_limit(self, limit_id: str) -> bool:
|
|
84
|
+
return bool(self._req("DELETE", f"/api/limits/{limit_id}")["removed"])
|
|
85
|
+
|
|
86
|
+
def price(self, model: str, inp: float, out: float) -> None:
|
|
87
|
+
self._req("POST", "/api/prices", json={"model": model, "input": inp, "output": out})
|
|
88
|
+
|
|
89
|
+
def usage(self, session: str | None = None) -> dict[str, Any]:
|
|
90
|
+
data: dict[str, Any] = self._req(
|
|
91
|
+
"GET", "/api/usage", params={"session": session} if session else {}
|
|
92
|
+
)
|
|
93
|
+
return data
|
|
94
|
+
|
|
95
|
+
def kill(self, session: str | None = None) -> int:
|
|
96
|
+
return int(
|
|
97
|
+
self._req("POST", "/api/kill", json={"session": session} if session else {})["stopped"]
|
|
98
|
+
)
|
|
99
|
+
|
|
100
|
+
def resume(self, session: str | None = None) -> None:
|
|
101
|
+
self._req("POST", "/api/resume", json={"session": session} if session else {})
|
|
102
|
+
|
|
103
|
+
def doctor(self) -> dict[str, Any]:
|
|
104
|
+
data: dict[str, Any] = self._req("GET", "/api/doctor")
|
|
105
|
+
return data
|
|
106
|
+
|
|
107
|
+
def ingest(self, client: str, payload: dict[str, Any], session: str | None) -> dict[str, Any]:
|
|
108
|
+
data: dict[str, Any] = self._req(
|
|
109
|
+
"POST",
|
|
110
|
+
f"/api/ingest/{client}",
|
|
111
|
+
json=payload,
|
|
112
|
+
params={"session": session} if session else {},
|
|
113
|
+
)
|
|
114
|
+
return data
|
|
115
|
+
|
|
116
|
+
def stream(self, sid: str, since: int = 0) -> Iterator[dict[str, Any]]:
|
|
117
|
+
import json
|
|
118
|
+
|
|
119
|
+
with self.client.stream(
|
|
120
|
+
"GET", f"/api/sessions/{sid}/stream", params={"since": since}, timeout=None
|
|
121
|
+
) as r:
|
|
122
|
+
for line in r.iter_lines():
|
|
123
|
+
if line.startswith("data: "):
|
|
124
|
+
yield json.loads(line[6:])
|