"""Document-scoped, auditable tools shared by CLI and API VQA agents.""" import argparse import json import math from pathlib import Path class DocumentTools: def __init__(self, root): self.root = Path(root).resolve() self.document = json.loads((self.root / "document.json").read_text()) self.pages = json.loads((self.root / "page_text.json").read_text()) self.text_pages_read = set() self.image_pages_read = set() self.searches = [] self.calculations = [] def overview(self): return { "document_id": self.document["id"], "title": self.document["title"], "page_count": len(self.pages), "content_page_count": self.document.get("content_page_count"), "sha256": self.document["sha256"], "page_indexing": "zero-based PDF indices", "pages": [ {"page": p["page"], "characters": len(p["text"]), "preview": p["text"][:350]} for p in self.pages ], } def search(self, terms, max_hits=30): if ( not isinstance(terms, list) or not 1 <= len(terms) <= 12 or any(not isinstance(t, str) or not 1 <= len(t) <= 200 for t in terms) ): raise ValueError("Provide 1–12 non-empty literal search terms, each at most 200 characters") max_hits = min(50, max(1, int(max_hits))) hits = [] for p in self.pages: lowered = p["text"].casefold() for term in terms: start = 0 while (pos := lowered.find(term.casefold(), start)) >= 0: hits.append( { "page": p["page"], "term": term, "offset": pos, "context": p["text"][max(0, pos - 150) : pos + len(term) + 250], } ) start = pos + max(1, len(term)) self.searches.append({"terms": terms, "match_count": len(hits)}) return { "scanned_text_pages": list(range(len(self.pages))), "match_count": len(hits), "hits": hits[:max_hits], "truncated_results": len(hits) > max_hits, "note": "A zero literal-match count does not prove semantic or visual absence.", } def read(self, pages, images=True): if ( not isinstance(pages, list) or not 1 <= len(pages) <= 8 or any(type(p) is not int or not 0 <= p < len(self.pages) for p in pages) ): raise ValueError("Read 1–8 valid zero-based page indices per call") result = [] for index in dict.fromkeys(pages): page = self.pages[index] item = {"page": index, "text": page["text"], "text_complete": True} self.text_pages_read.add(index) if images: item["image_path"] = str(self.root / "pages" / f"page{index:03d}.png") self.image_pages_read.add(index) result.append(item) return { "document_id": self.document["id"], "pages": result, "note": "Image paths must actually be opened by the CLI; the API driver delivers requested images.", } def calculate(self, operator, operands): if ( not isinstance(operands, list) or not 1 <= len(operands) <= 100 or any(type(x) not in (int, float) or not math.isfinite(x) or abs(x) > 1e15 for x in operands) ): raise ValueError("Provide at most 100 finite numeric operands") if operator == "+": result = sum(operands) elif operator == "-" and len(operands) == 2: result = operands[0] - operands[1] elif operator == "*": result = math.prod(operands) elif operator == "/" and len(operands) == 2: result = operands[0] / operands[1] elif operator == "min": result = min(operands) elif operator == "max": result = max(operands) else: raise ValueError("Supported operators: +, -, *, /, min, max; subtraction/division need two operands") if not math.isfinite(result): raise ValueError("Non-finite result") record = {"operator": operator, "operands": operands, "result": result} self.calculations.append(record) return record def call(self, name, arguments): if name == "document_overview": return self.overview() if name == "search_document": return self.search(**arguments) if name == "read_pages": return self.read(**arguments) if name == "calculate": return self.calculate(**arguments) raise ValueError("Unknown document tool") TOOL_SCHEMAS = [ { "type": "function", "function": { "name": "document_overview", "description": "Get full-document page count, identity, source hash and page previews.", "parameters": {"type": "object", "properties": {}, "additionalProperties": False}, }, }, { "type": "function", "function": { "name": "search_document", "description": "Search every page's extracted text for literal terms, including synonyms in separate terms. This does not prove visual absence.", "parameters": { "type": "object", "properties": { "terms": {"type": "array", "items": {"type": "string"}}, "max_hits": {"type": "integer"}, }, "required": ["terms"], "additionalProperties": False, }, }, }, { "type": "function", "function": { "name": "read_pages", "description": "Read full text and request actual page images for up to eight zero-based PDF pages; use the images for tables and figures.", "parameters": { "type": "object", "properties": { "pages": {"type": "array", "items": {"type": "integer"}}, "images": {"type": "boolean"}, }, "required": ["pages"], "additionalProperties": False, }, }, }, { "type": "function", "function": { "name": "calculate", "description": "Execute arithmetic on observed numeric operands. Establish operand provenance from document pages first.", "parameters": { "type": "object", "properties": { "operator": {"type": "string", "enum": ["+", "-", "*", "/", "min", "max"]}, "operands": {"type": "array", "items": {"type": "number"}}, }, "required": ["operator", "operands"], "additionalProperties": False, }, }, }, ] def main(): parser = argparse.ArgumentParser() parser.add_argument("tool", choices=["document_overview", "search_document", "read_pages", "calculate"]) parser.add_argument("arguments", nargs="?", default="{}", help="Tool arguments as JSON") parser.add_argument("--root", type=Path, default=Path.cwd()) args = parser.parse_args() try: result = DocumentTools(args.root).call(args.tool, json.loads(args.arguments)) except Exception as exc: result = {"error": type(exc).__name__, "message": str(exc)} print(json.dumps(result, ensure_ascii=False)) if __name__ == "__main__": main()