venice-bridge 0.2.1__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.
- tolerant_parser.py +364 -0
- venice_adapters.py +462 -0
- venice_bridge-0.2.1.data/scripts/claude-venice +104 -0
- venice_bridge-0.2.1.dist-info/METADATA +795 -0
- venice_bridge-0.2.1.dist-info/RECORD +12 -0
- venice_bridge-0.2.1.dist-info/WHEEL +5 -0
- venice_bridge-0.2.1.dist-info/entry_points.txt +3 -0
- venice_bridge-0.2.1.dist-info/licenses/LICENSE +21 -0
- venice_bridge-0.2.1.dist-info/licenses/NOTICE.md +9 -0
- venice_bridge-0.2.1.dist-info/licenses/THIRD_PARTY_LICENSE-opencode-venice-web.txt +21 -0
- venice_bridge-0.2.1.dist-info/top_level.txt +3 -0
- venice_bridge.py +2450 -0
tolerant_parser.py
ADDED
|
@@ -0,0 +1,364 @@
|
|
|
1
|
+
"""Python port of opencode-venice-web's tolerant envelope parser (lenient-json.mjs + emulate.mjs:573-1020).
|
|
2
|
+
Native DSML invoke parsing (emulate.mjs:661-680) and cleanLeakedEnvelope (788-809) are left out."""
|
|
3
|
+
import json, re
|
|
4
|
+
from typing import Any, Dict, List, Optional, Tuple
|
|
5
|
+
|
|
6
|
+
# ---- lenient-json.mjs:30-207 ----------------------------------------------------------
|
|
7
|
+
_WS = " \t\n\r"
|
|
8
|
+
_SIMPLE = {'"': '"', "\\": "\\", "/": "/", "b": "\b", "f": "\f", "n": "\n", "r": "\r", "t": "\t"}
|
|
9
|
+
_NUM = re.compile(r"-?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?")
|
|
10
|
+
_LIT = re.compile(r"(?:true|false|null)(?!\w)")
|
|
11
|
+
_HEX4 = re.compile(r"[0-9a-fA-F]{4}")
|
|
12
|
+
|
|
13
|
+
class _Reader:
|
|
14
|
+
def __init__(self, text: str, pos: int) -> None:
|
|
15
|
+
self.t, self.p = text, pos
|
|
16
|
+
|
|
17
|
+
def _peek(self) -> Optional[str]:
|
|
18
|
+
return self.t[self.p] if self.p < len(self.t) else None
|
|
19
|
+
|
|
20
|
+
def _skip(self) -> None:
|
|
21
|
+
while self.p < len(self.t) and self.t[self.p] in _WS:
|
|
22
|
+
self.p += 1
|
|
23
|
+
|
|
24
|
+
def _solid(self, i: int) -> Tuple[Optional[str], int]:
|
|
25
|
+
while i < len(self.t) and self.t[i] in _WS:
|
|
26
|
+
i += 1
|
|
27
|
+
return (self.t[i] if i < len(self.t) else None), i
|
|
28
|
+
|
|
29
|
+
def _starts_value(self, i: int) -> bool:
|
|
30
|
+
c = self.t[i] if i < len(self.t) else None
|
|
31
|
+
if c is None or c not in '"{[-0123456789tfn':
|
|
32
|
+
return False
|
|
33
|
+
return c not in "tfn" or bool(_LIT.match(self.t, i))
|
|
34
|
+
|
|
35
|
+
def _closes_string(self, q: int) -> bool: # a quote ends a string only if JSON can follow it
|
|
36
|
+
c, i = self._solid(q + 1)
|
|
37
|
+
if c is None or c in "}]:":
|
|
38
|
+
return True
|
|
39
|
+
if c != ",":
|
|
40
|
+
return False
|
|
41
|
+
c, i = self._solid(i + 1)
|
|
42
|
+
while c == ",":
|
|
43
|
+
c, i = self._solid(i + 1)
|
|
44
|
+
return c is None or c in "}]" or self._starts_value(i)
|
|
45
|
+
|
|
46
|
+
def value(self) -> Any:
|
|
47
|
+
self._skip()
|
|
48
|
+
c = self._peek()
|
|
49
|
+
if c == "{":
|
|
50
|
+
return self._object({})
|
|
51
|
+
if c == "[":
|
|
52
|
+
return self._array()
|
|
53
|
+
if c == '"':
|
|
54
|
+
return self._string()
|
|
55
|
+
if c is not None and (c == "-" or c in "0123456789"):
|
|
56
|
+
m = _NUM.match(self.t, self.p)
|
|
57
|
+
if not m:
|
|
58
|
+
raise ValueError(f"bad number at {self.p}")
|
|
59
|
+
self.p = m.end()
|
|
60
|
+
return json.loads(m.group(0))
|
|
61
|
+
for word, val in (("true", True), ("false", False), ("null", None)):
|
|
62
|
+
if self.t.startswith(word, self.p):
|
|
63
|
+
self.p += len(word)
|
|
64
|
+
return val
|
|
65
|
+
raise ValueError(f"unexpected {c!r} at {self.p}")
|
|
66
|
+
|
|
67
|
+
def _string(self) -> str:
|
|
68
|
+
self.p += 1
|
|
69
|
+
out: List[str] = []
|
|
70
|
+
t = self.t
|
|
71
|
+
while self.p < len(t):
|
|
72
|
+
c = t[self.p]
|
|
73
|
+
if c == "\\":
|
|
74
|
+
n = t[self.p + 1] if self.p + 1 < len(t) else ""
|
|
75
|
+
if n in _SIMPLE and n:
|
|
76
|
+
out.append(_SIMPLE[n]); self.p += 2; continue
|
|
77
|
+
if n == "u" and _HEX4.fullmatch(t, self.p + 2, self.p + 6):
|
|
78
|
+
code = int(t[self.p + 2:self.p + 6], 16)
|
|
79
|
+
self.p += 6
|
|
80
|
+
# JS joins surrogate pairs by itself; Python must, or utf-8 encoding fails later
|
|
81
|
+
if 0xD800 <= code < 0xDC00 and t.startswith("\\u", self.p) and _HEX4.fullmatch(t, self.p + 2, self.p + 6):
|
|
82
|
+
low = int(t[self.p + 2:self.p + 6], 16)
|
|
83
|
+
if 0xDC00 <= low < 0xE000:
|
|
84
|
+
code = 0x10000 + ((code - 0xD800) << 10) + (low - 0xDC00)
|
|
85
|
+
self.p += 6
|
|
86
|
+
out.append(chr(code) if not 0xD800 <= code < 0xE000 else "�")
|
|
87
|
+
continue
|
|
88
|
+
out.append(c); self.p += 1; continue # invalid escape kept as written
|
|
89
|
+
if c == '"':
|
|
90
|
+
if self._closes_string(self.p):
|
|
91
|
+
self.p += 1
|
|
92
|
+
return "".join(out)
|
|
93
|
+
out.append(c)
|
|
94
|
+
self.p += 1
|
|
95
|
+
return "".join(out) # end of input closes it
|
|
96
|
+
|
|
97
|
+
def _object(self, target: Dict[str, Any]) -> Dict[str, Any]:
|
|
98
|
+
if self._peek() == "{":
|
|
99
|
+
self.p += 1
|
|
100
|
+
while True:
|
|
101
|
+
self._skip()
|
|
102
|
+
c = self._peek()
|
|
103
|
+
if c is None:
|
|
104
|
+
return target
|
|
105
|
+
if c == "}":
|
|
106
|
+
self.p += 1
|
|
107
|
+
return target
|
|
108
|
+
if c == "]":
|
|
109
|
+
return target # the parent array closes; this object ends with it
|
|
110
|
+
if c == ",":
|
|
111
|
+
self.p += 1
|
|
112
|
+
continue
|
|
113
|
+
if c == "{" and target:
|
|
114
|
+
return target # a sibling starts: we were never closed
|
|
115
|
+
if c != '"':
|
|
116
|
+
raise ValueError(f"expected a key at {self.p}")
|
|
117
|
+
key = self._string()
|
|
118
|
+
self._skip()
|
|
119
|
+
if self._peek() != ":":
|
|
120
|
+
raise ValueError(f"expected ':' at {self.p}")
|
|
121
|
+
self.p += 1
|
|
122
|
+
target[key] = self.value()
|
|
123
|
+
|
|
124
|
+
def _array(self) -> List[Any]:
|
|
125
|
+
self.p += 1
|
|
126
|
+
out: List[Any] = []
|
|
127
|
+
while True:
|
|
128
|
+
self._skip()
|
|
129
|
+
c = self._peek()
|
|
130
|
+
if c is None:
|
|
131
|
+
return out
|
|
132
|
+
if c == "]":
|
|
133
|
+
self.p += 1
|
|
134
|
+
return out
|
|
135
|
+
if c == "}":
|
|
136
|
+
return out # the parent object closes; this array ends with it
|
|
137
|
+
if c == ",":
|
|
138
|
+
self.p += 1
|
|
139
|
+
continue
|
|
140
|
+
if c == '"' and out and isinstance(out[-1], dict):
|
|
141
|
+
mark = self.p
|
|
142
|
+
self._string()
|
|
143
|
+
is_key = self._solid(self.p)[0] == ":"
|
|
144
|
+
self.p = mark
|
|
145
|
+
if is_key: # `{...}, "key": value` inside an array: the object closed too early
|
|
146
|
+
self._object(out[-1])
|
|
147
|
+
continue
|
|
148
|
+
out.append(self.value())
|
|
149
|
+
|
|
150
|
+
def read_lenient(text: str, start: int = 0) -> Tuple[Any, int]:
|
|
151
|
+
r = _Reader(text, start)
|
|
152
|
+
try:
|
|
153
|
+
return r.value(), r.p
|
|
154
|
+
except RecursionError as exc:
|
|
155
|
+
raise ValueError("too deep") from exc
|
|
156
|
+
|
|
157
|
+
# ---- emulate.mjs:573-619 scanners -------------------------------------------------------
|
|
158
|
+
def _scan(text: str, start: int, open_ch: str = "{", close_ch: str = "}") -> int:
|
|
159
|
+
depth, in_str, esc = 0, False, False
|
|
160
|
+
for i in range(start, len(text)):
|
|
161
|
+
c = text[i]
|
|
162
|
+
if in_str:
|
|
163
|
+
if esc: esc = False
|
|
164
|
+
elif c == "\\": esc = True
|
|
165
|
+
elif c == '"': in_str = False
|
|
166
|
+
continue
|
|
167
|
+
if c == '"': in_str = True
|
|
168
|
+
elif c == open_ch: depth += 1
|
|
169
|
+
elif c == close_ch:
|
|
170
|
+
depth -= 1
|
|
171
|
+
if depth == 0:
|
|
172
|
+
return i + 1
|
|
173
|
+
return -1
|
|
174
|
+
|
|
175
|
+
# ---- emulate.mjs:627-655 markup stripping ------------------------------------------------
|
|
176
|
+
_BAR = r"[||]\s*DSML\s*[||]"
|
|
177
|
+
_PARAM_BLOCK = re.compile(rf'<\s*(?:{_BAR}\s*)?parameter\s+name="([^"]+)"[^>]*>([\s\S]*?)</\s*(?:{_BAR}\s*)?parameter\s*>', re.I)
|
|
178
|
+
_MARKUP = re.compile(rf"</?\s*(?:{_BAR}\s*)?(?:function_calls|calls|invoke|parameter|tool_calls?|tool_response|tool_result)\b[^>]*>", re.I)
|
|
179
|
+
|
|
180
|
+
def strip_tool_markup(text: str) -> str:
|
|
181
|
+
text = _PARAM_BLOCK.sub(lambda m: m.group(2) if m.group(1) == "content" else "", text or "")
|
|
182
|
+
return re.sub(r"\n{3,}", "\n\n", _MARKUP.sub("", text)).strip()
|
|
183
|
+
|
|
184
|
+
# ---- emulate.mjs:697-785 text repairs ----------------------------------------------------
|
|
185
|
+
_BOUNDARY = re.compile(r',[\s\r\n]*"[\w$]+"\s*:')
|
|
186
|
+
_TRAILING = re.compile(r",\s*([}\]])")
|
|
187
|
+
|
|
188
|
+
def _repair_arguments(t: str) -> str: # quote a raw (non-JSON) run after "arguments":
|
|
189
|
+
out, last = [], 0
|
|
190
|
+
for m in re.finditer(r'"arguments"\s*:\s*', t):
|
|
191
|
+
start = m.end()
|
|
192
|
+
if m.start() < last:
|
|
193
|
+
continue
|
|
194
|
+
out.append(t[last:start]); last = start
|
|
195
|
+
if start < len(t) and t[start] in '{["-0123456789tfn':
|
|
196
|
+
continue
|
|
197
|
+
b = _BOUNDARY.search(t, start)
|
|
198
|
+
raw = t[start:(b.start() if b else len(t))].rstrip()
|
|
199
|
+
out.append(json.dumps(raw, ensure_ascii=False)); last = start + len(raw)
|
|
200
|
+
out.append(t[last:])
|
|
201
|
+
return "".join(out)
|
|
202
|
+
|
|
203
|
+
def _parse_loose(s: str) -> Optional[Dict[str, Any]]:
|
|
204
|
+
for step in (lambda x: x, lambda x: _TRAILING.sub(r"\1", x), _repair_arguments,
|
|
205
|
+
lambda x: _TRAILING.sub(r"\1", _repair_arguments(x))):
|
|
206
|
+
try:
|
|
207
|
+
v = json.loads(step(s), strict=False) # strict=False = repairJsonControlChars
|
|
208
|
+
except ValueError:
|
|
209
|
+
continue
|
|
210
|
+
if isinstance(v, dict):
|
|
211
|
+
return v
|
|
212
|
+
return None
|
|
213
|
+
|
|
214
|
+
def _salvage_calls(s: str) -> List[Dict[str, Any]]:
|
|
215
|
+
calls = []
|
|
216
|
+
for m in re.finditer(r'"name"\s*:\s*"([^"]+)"', s):
|
|
217
|
+
am = re.compile(r'"arguments"\s*:\s*').search(s, m.end())
|
|
218
|
+
if not am or am.start() - m.end() > 40:
|
|
219
|
+
calls.append({"name": m.group(1), "arguments": {}}); continue
|
|
220
|
+
start = am.end()
|
|
221
|
+
trimmed = s[start:].lstrip()
|
|
222
|
+
off = len(s) - start - len(trimmed)
|
|
223
|
+
if trimmed[:1] in ("{", "["):
|
|
224
|
+
bal = _scan(trimmed, 0, trimmed[0], "}" if trimmed[0] == "{" else "]")
|
|
225
|
+
end = start + (off + bal if bal > 0 else len(s) - start)
|
|
226
|
+
else:
|
|
227
|
+
b = _BOUNDARY.search(s, start)
|
|
228
|
+
end = b.start() if b else len(s)
|
|
229
|
+
raw = re.sub(r"[\s,]+$", "", s[start:end])
|
|
230
|
+
try:
|
|
231
|
+
args = json.loads(raw, strict=False)
|
|
232
|
+
except ValueError:
|
|
233
|
+
args = None
|
|
234
|
+
calls.append({"name": m.group(1), "arguments": args if isinstance(args, dict) else {"content": raw}})
|
|
235
|
+
return calls
|
|
236
|
+
|
|
237
|
+
# ---- emulate.mjs:811-883 envelope helpers ------------------------------------------------
|
|
238
|
+
_MISSING = object()
|
|
239
|
+
_CALL_KEYS = {"name", "id", "type", "arguments", "function"}
|
|
240
|
+
_OBJ_START = re.compile(r'\{\s*"')
|
|
241
|
+
STATUSES = {"continue", "done", "ask"}
|
|
242
|
+
|
|
243
|
+
def _is_envelope(v: Any) -> bool:
|
|
244
|
+
return isinstance(v, dict) and (isinstance(v.get("tool_calls"), list) or isinstance(v.get("content"), str))
|
|
245
|
+
|
|
246
|
+
def _unwrap_nested(env: Dict[str, Any], depth: int = 0) -> Dict[str, Any]:
|
|
247
|
+
calls = env.get("tool_calls")
|
|
248
|
+
inner = env["content"].strip() if isinstance(env.get("content"), str) else ""
|
|
249
|
+
if depth > 2 or (isinstance(calls, list) and calls) or not inner.startswith("{") or '"tool_calls"' not in inner:
|
|
250
|
+
return env
|
|
251
|
+
try:
|
|
252
|
+
v = json.loads(inner, strict=False)
|
|
253
|
+
except ValueError:
|
|
254
|
+
try:
|
|
255
|
+
v = read_lenient(inner, 0)[0]
|
|
256
|
+
except ValueError:
|
|
257
|
+
v = None
|
|
258
|
+
if not _is_envelope(v):
|
|
259
|
+
return env
|
|
260
|
+
v = dict(v)
|
|
261
|
+
if v.get("status") is None:
|
|
262
|
+
v["status"] = env.get("status")
|
|
263
|
+
return _unwrap_nested(v, depth + 1)
|
|
264
|
+
|
|
265
|
+
def _build_call(call: Any) -> Optional[Dict[str, Any]]:
|
|
266
|
+
if not isinstance(call, dict):
|
|
267
|
+
return None
|
|
268
|
+
name, args = call.get("name"), call.get("arguments", _MISSING)
|
|
269
|
+
fn = call.get("function")
|
|
270
|
+
if not isinstance(name, str) and isinstance(fn, dict) and isinstance(fn.get("name"), str):
|
|
271
|
+
name, args = fn["name"], fn.get("arguments", _MISSING) # OpenAI shape
|
|
272
|
+
if not isinstance(name, str):
|
|
273
|
+
return None
|
|
274
|
+
stray = {k: v for k, v in call.items() if k not in _CALL_KEYS}
|
|
275
|
+
if args is _MISSING:
|
|
276
|
+
args = stray # arguments written at the call's top level
|
|
277
|
+
else:
|
|
278
|
+
if isinstance(args, str):
|
|
279
|
+
try:
|
|
280
|
+
parsed = json.loads(args, strict=False)
|
|
281
|
+
except ValueError:
|
|
282
|
+
parsed = None
|
|
283
|
+
if isinstance(parsed, dict):
|
|
284
|
+
args = parsed
|
|
285
|
+
if isinstance(args, dict):
|
|
286
|
+
for k, v in stray.items(): # `arguments` closed one key too early
|
|
287
|
+
args.setdefault(k, v)
|
|
288
|
+
if isinstance(args, str):
|
|
289
|
+
args = {"content": args}
|
|
290
|
+
return {"name": name, "arguments": {} if args is None else args}
|
|
291
|
+
|
|
292
|
+
# ---- emulate.mjs:899-1020 the scan -------------------------------------------------------
|
|
293
|
+
def parse_tool_reply(text: str) -> Dict[str, Any]:
|
|
294
|
+
"""{'content', 'calls', 'saw_envelope', 'broken', 'status'}; calls are [{'name','arguments'}] or None."""
|
|
295
|
+
parts: List[str] = []
|
|
296
|
+
calls: List[Dict[str, Any]] = []
|
|
297
|
+
saw = broken = False
|
|
298
|
+
status = None
|
|
299
|
+
pending, i = "", 0
|
|
300
|
+
while i < len(text):
|
|
301
|
+
m_start = _OBJ_START.search(text, i)
|
|
302
|
+
start = m_start.start() if m_start else -1
|
|
303
|
+
if start < 0:
|
|
304
|
+
pending += text[i:]
|
|
305
|
+
break
|
|
306
|
+
pending += text[i:start]
|
|
307
|
+
end = _scan(text, start)
|
|
308
|
+
sl = text[start:end] if end > 0 else ""
|
|
309
|
+
parsed = _parse_loose(sl) if sl else None
|
|
310
|
+
if not _is_envelope(parsed):
|
|
311
|
+
try:
|
|
312
|
+
val, lend = read_lenient(text, start)
|
|
313
|
+
if _is_envelope(val):
|
|
314
|
+
parsed, end, sl = val, lend, text[start:lend]
|
|
315
|
+
except ValueError:
|
|
316
|
+
pass
|
|
317
|
+
if _is_envelope(parsed):
|
|
318
|
+
parsed = _unwrap_nested(parsed)
|
|
319
|
+
piece = parsed["content"].strip() if isinstance(parsed, dict) and isinstance(parsed.get("content"), str) else ""
|
|
320
|
+
region = sl or text[start:]
|
|
321
|
+
looks = parsed is not None or '"tool_calls"' in region
|
|
322
|
+
salvaged = None
|
|
323
|
+
has_list = isinstance(parsed, dict) and isinstance(parsed.get("tool_calls"), list)
|
|
324
|
+
if looks and not has_list and not piece:
|
|
325
|
+
salvaged = _salvage_calls(region) or None
|
|
326
|
+
here = looks and (_is_envelope(parsed) or bool(salvaged))
|
|
327
|
+
if not here:
|
|
328
|
+
if re.match(r'\{\s*"(?:content|tool_calls|status)"\s*:', region.lstrip()):
|
|
329
|
+
broken = True # an envelope we could not read: never show it raw
|
|
330
|
+
if pending.strip():
|
|
331
|
+
parts.append(pending.strip())
|
|
332
|
+
pending = ""
|
|
333
|
+
m = re.search(r'"content"\s*:\s*"((?:[^"\\]|\\.)*)"', region)
|
|
334
|
+
if m:
|
|
335
|
+
try:
|
|
336
|
+
parts.append(json.loads('"%s"' % m.group(1), strict=False).strip())
|
|
337
|
+
except ValueError:
|
|
338
|
+
pass
|
|
339
|
+
break
|
|
340
|
+
pending += "{"
|
|
341
|
+
i = start + 1
|
|
342
|
+
continue
|
|
343
|
+
saw = True
|
|
344
|
+
st = parsed.get("status") if isinstance(parsed, dict) else None
|
|
345
|
+
if isinstance(st, str) and st.strip().lower() in STATUSES:
|
|
346
|
+
status = st.strip().lower()
|
|
347
|
+
if pending.strip():
|
|
348
|
+
parts.append(pending.strip())
|
|
349
|
+
pending = ""
|
|
350
|
+
if piece:
|
|
351
|
+
parts.append(piece)
|
|
352
|
+
for call in (salvaged or (parsed.get("tool_calls") if isinstance(parsed, dict) else None) or []):
|
|
353
|
+
built = _build_call(call)
|
|
354
|
+
if built:
|
|
355
|
+
calls.append(built)
|
|
356
|
+
i = end if end > 0 else len(text)
|
|
357
|
+
if pending.strip():
|
|
358
|
+
parts.append(pending.strip())
|
|
359
|
+
content = strip_tool_markup("\n".join(p for p in parts if p))
|
|
360
|
+
if not saw:
|
|
361
|
+
return {"content": content if broken else strip_tool_markup(text.strip()), "calls": None,
|
|
362
|
+
"saw_envelope": False, "broken": broken, "status": None}
|
|
363
|
+
return {"content": content, "calls": calls or None, "saw_envelope": True,
|
|
364
|
+
"broken": broken and not calls, "status": status}
|