"""Reference tool runtime for models trained on the OPUS-5.5-DATABASE `tools` config. The same implementations are used (a) to generate the verified OPUS-synth-tools examples — every tool result in the data is the real output of these functions — and (b) at inference time, so a fine-tuned model can actually call them: from opusdb.agent_tools import TOOL_SPECS, call_tool, parse_tool_calls text = model_generate(messages, tools=TOOL_SPECS) for call in parse_tool_calls(text): result = call_tool(call["name"], call["arguments"]) Tools: calculator, python (subprocess with timeout), date_calc, unit_convert. """ import ast import datetime as dt import json import math import operator import re import subprocess import sys import tempfile from fractions import Fraction TOOL_SPECS = [ {"type": "function", "function": { "name": "calculator", "description": "Evaluate an arithmetic expression exactly. Supports + - * / // % **, parentheses and the " "functions sqrt, abs, round, floor, ceil, log, log10, exp, sin, cos, tan, factorial, gcd, " "and the constants pi and e.", "parameters": {"type": "object", "properties": { "expression": {"type": "string", "description": "e.g. '(1250 * 1.07**3) - 400'"}}, "required": ["expression"]}}}, {"type": "function", "function": { "name": "python", "description": "Run a short Python 3 program and return what it prints (stdout) or the last error line. " "Use print() to return results. Intended for computation only.", "parameters": {"type": "object", "properties": { "code": {"type": "string", "description": "Python source code"}}, "required": ["code"]}}}, {"type": "function", "function": { "name": "date_calc", "description": "Date arithmetic. operation='add_days' returns date + days; 'diff' returns the number of days " "from date to other_date; 'weekday' returns the weekday name of date. Dates are YYYY-MM-DD.", "parameters": {"type": "object", "properties": { "operation": {"type": "string", "enum": ["add_days", "diff", "weekday"]}, "date": {"type": "string"}, "days": {"type": "integer"}, "other_date": {"type": "string"}}, "required": ["operation", "date"]}}}, {"type": "function", "function": { "name": "unit_convert", "description": "Convert a value between units of length (mm, cm, m, km, in, ft, yd, mi), mass (mg, g, kg, " "lb, oz), volume (ml, l, gal, cup), time (s, min, h, day, week) or temperature (C, F, K).", "parameters": {"type": "object", "properties": { "value": {"type": "number"}, "from_unit": {"type": "string"}, "to_unit": {"type": "string"}}, "required": ["value", "from_unit", "to_unit"]}}}, ] TOOL_NAMES = {t["function"]["name"] for t in TOOL_SPECS} # ------------------------------------------------------------------ calculator _BIN = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.FloorDiv: operator.floordiv, ast.Mod: operator.mod, ast.Pow: operator.pow} _FUNCS = {"sqrt": math.sqrt, "abs": abs, "round": round, "floor": math.floor, "ceil": math.ceil, "log": math.log, "log10": math.log10, "exp": math.exp, "sin": math.sin, "cos": math.cos, "tan": math.tan, "factorial": math.factorial, "gcd": math.gcd} _CONSTS = {"pi": math.pi, "e": math.e} def _calc(node): if isinstance(node, ast.Constant) and type(node.value) in (int, float): return Fraction(node.value) if isinstance(node.value, int) else Fraction(str(node.value)) if isinstance(node, ast.Name) and node.id in _CONSTS: return _CONSTS[node.id] if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)): v = _calc(node.operand) return -v if isinstance(node.op, ast.USub) else v if isinstance(node, ast.BinOp) and type(node.op) in _BIN: a, b = _calc(node.left), _calc(node.right) if isinstance(node.op, ast.Pow): if abs(b) > 1000 or (isinstance(a, Fraction) and abs(a) > 10 ** 6 and b > 50): raise ValueError("exponent too large") if isinstance(b, Fraction) and b.denominator != 1: return float(a) ** float(b) return _BIN[type(node.op)](a, b) if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id in _FUNCS and not node.keywords: args = [_calc(a) for a in node.args] if node.func.id == "factorial" and (len(args) != 1 or args[0] > 1000): raise ValueError("factorial argument too large") if node.func.id in ("factorial", "gcd"): args = [int(a) for a in args] elif node.func.id != "abs" and node.func.id != "round": args = [float(a) for a in args] return _FUNCS[node.func.id](*args) raise ValueError("unsupported expression") def format_number(v): if isinstance(v, Fraction): if v.denominator == 1: return str(v.numerator) v = float(v) if isinstance(v, float): if math.isinf(v) or math.isnan(v): return str(v) if v == int(v) and abs(v) < 1e15: return str(int(v)) return f"{v:.10g}" return str(v) def calculator(expression: str): if len(expression) > 300: return {"error": "expression too long"} try: tree = ast.parse(expression.replace("^", "**").replace("×", "*").replace("÷", "/"), mode="eval") return {"result": format_number(_calc(tree.body))} except ZeroDivisionError: return {"error": "division by zero"} except (ValueError, SyntaxError, TypeError, OverflowError) as exc: return {"error": str(exc) or type(exc).__name__} # ------------------------------------------------------------------ python runner def python(code: str, timeout: float = 5.0): """Runs code in a separate isolated-mode interpreter with a timeout. This is NOT a security sandbox: when serving untrusted users, run it inside a container/VM without network or credentials. """ with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as fh: fh.write(code) path = fh.name try: res = subprocess.run([sys.executable, "-I", "-S", path], capture_output=True, text=True, timeout=timeout, cwd=tempfile.gettempdir()) except subprocess.TimeoutExpired: return {"error": f"timeout after {timeout} s"} if res.returncode != 0: last = res.stderr.strip().splitlines()[-1] if res.stderr.strip() else "error" return {"error": last} return {"stdout": res.stdout[-4000:]} # ------------------------------------------------------------------ dates & units def date_calc(operation: str, date: str, days: int = None, other_date: str = None): try: d = dt.date.fromisoformat(date) if operation == "add_days": return {"result": (d + dt.timedelta(days=int(days))).isoformat()} if operation == "diff": return {"result": (dt.date.fromisoformat(other_date) - d).days} if operation == "weekday": return {"result": d.strftime("%A")} return {"error": f"unknown operation {operation}"} except (TypeError, ValueError) as exc: return {"error": str(exc)} _UNITS = { # factor to SI base of each dimension "length": {"mm": 0.001, "cm": 0.01, "m": 1, "km": 1000, "in": 0.0254, "ft": 0.3048, "yd": 0.9144, "mi": 1609.344}, "mass": {"mg": 1e-6, "g": 0.001, "kg": 1, "lb": 0.45359237, "oz": 0.028349523125}, "volume": {"ml": 0.001, "l": 1, "gal": 3.785411784, "cup": 0.2365882365}, "time": {"s": 1, "min": 60, "h": 3600, "day": 86400, "week": 604800}, } def unit_convert(value, from_unit: str, to_unit: str): f, t = from_unit.strip(), to_unit.strip() temps = {"C", "F", "K"} if f in temps and t in temps: c = value if f == "C" else (value - 32) * 5 / 9 if f == "F" else value - 273.15 out = c if t == "C" else c * 9 / 5 + 32 if t == "F" else c + 273.15 return {"result": round(out, 6)} for table in _UNITS.values(): if f in table and t in table: return {"result": round(value * table[f] / table[t], 6)} return {"error": f"cannot convert {from_unit} to {to_unit}"} IMPL = {"calculator": calculator, "python": python, "date_calc": date_calc, "unit_convert": unit_convert} def call_tool(name, arguments): if name not in IMPL: return {"error": f"unknown tool {name}"} if isinstance(arguments, str): try: arguments = json.loads(arguments) except ValueError: return {"error": "arguments are not valid JSON"} try: return IMPL[name](**arguments) except TypeError as exc: return {"error": str(exc)} # ------------------------------------------------------------------ parsing model output _TAGGED = re.compile(r"\s*(\{.*?\})\s*", re.S) def parse_tool_calls(text): """Extract tool calls from generated text (Hermes/Qwen `{...}` or bare JSON).""" calls = [] blobs = _TAGGED.findall(text) if not blobs: m = re.search(r"\{.*\}", text, re.S) blobs = [m.group(0)] if m else [] for b in blobs: try: obj = json.loads(b) except ValueError: continue if isinstance(obj, dict) and "name" in obj: args = obj.get("arguments", obj.get("parameters", {})) if isinstance(args, str): try: args = json.loads(args) except ValueError: pass calls.append({"name": obj["name"], "arguments": args}) return calls