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 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}