@allansantos-dev/smart-tool 0.9.43 → 0.9.45

package/document_text.py

@@ -115,39 +115,157 @@ def _local(tag):
     return tag.rsplit('}', 1)[-1]
 
 
+def _docx_namespace(root):
+    """The WordprocessingML namespace prefix (transitional or strict) of a parsed part."""
+    return W if root.tag.startswith(W) else '{http://purl.oclc.org/ooxml/wordprocessingml/main}'
+
+
+def _docx_text(paragraph, namespace):
+    """Text of one `w:p`: runs, tabs and line breaks; a nested paragraph (text box) is not part of it."""
+    pending = list(reversed(paragraph))
+    pieces = []
+    while pending:
+        child = pending.pop()
+        if child.tag == namespace + 'p':
+            continue
+        if child.tag == namespace + 't':
+            pieces.append(child.text or '')
+        elif child.tag == namespace + 'tab':
+            pieces.append('\t')
+        elif child.tag in (namespace + 'br', namespace + 'cr'):
+            pieces.append('\n')
+        else:
+            pending.extend(reversed(child))
+    return ''.join(pieces)
+
+
+def _docx_extra_parts(package):
+    """Names of the header, footer, footnote and endnote parts of a .docx, in a stable order."""
+    return sorted(name for name in package.entries if re.fullmatch(
+        r'word/(?:header\d+|footer\d+|footnotes|endnotes)\.xml', name))
+
+
 def extract_docx(data):
     """Text of a .docx: body, headers, footers, footnotes and endnotes, one line per non-empty paragraph.
 
     Parameters: data (the file bytes). Returns: UTF-8 text bytes. Raises: DocumentError with a readable reason for a
     corrupt, encrypted or oversized package, or one with a DOCTYPE or entity."""
     with _open_package(data, 'DOCX', 'word/document.xml') as package:
-        names = ['word/document.xml'] + sorted(name for name in package.entries if re.fullmatch(
-            r'word/(?:header\d+|footer\d+|footnotes|endnotes)\.xml', name))
         paragraphs = _Lines('DOCX')
-        for name in names:
+        for name in ['word/document.xml'] + _docx_extra_parts(package):
             root = package.parse(name)
-            namespace = W if root.tag.startswith(W) else '{http://purl.oclc.org/ooxml/wordprocessingml/main}'
+            namespace = _docx_namespace(root)
             for paragraph in root.iter(namespace + 'p'):
-                def parts(node):
-                    pending = list(reversed(node))
-                    while pending:
-                        child = pending.pop()
-                        if child.tag == namespace + 'p':
-                            continue
-                        if child.tag == namespace + 't':
-                            yield child.text or ''
-                        elif child.tag == namespace + 'tab':
-                            yield '\t'
-                        elif child.tag in (namespace + 'br', namespace + 'cr'):
-                            yield '\n'
-                        else:
-                            pending.extend(reversed(child))
-                text = ''.join(parts(paragraph))
+                text = _docx_text(paragraph, namespace)
                 if text.strip():
                     paragraphs.add(text)
         return ('\n'.join(paragraphs) + '\n' if paragraphs else '').encode('utf-8')
 
 
+def _docx_heading_levels(package, namespace):
+    """`{styleId: level}` of the heading styles of word/styles.xml (the style name is `heading N` in every language,
+    `Title` is level 1); empty when the part is missing."""
+    if 'word/styles.xml' not in package.entries:
+        return {}
+    levels = {}
+    for style in package.parse('word/styles.xml').iter(namespace + 'style'):
+        name = next((node.get(namespace + 'val', '') for node in style if node.tag == namespace + 'name'), '').lower()
+        found = re.fullmatch(r'heading (\d)', name)
+        if found or name == 'title':
+            levels[style.get(namespace + 'styleId')] = int(found.group(1)) if found else 1
+    return levels
+
+
+def _docx_paragraph_line(paragraph, namespace, levels):
+    """Markdown line of a paragraph: `#` heading by style or outline level, `- ` item (indented by level) for a list
+    paragraph, else the plain text; an empty string for a paragraph without text."""
+    text = ' '.join(_docx_text(paragraph, namespace).split())
+    if not text:
+        return ''
+    properties = next((node for node in paragraph if node.tag == namespace + 'pPr'), None)
+    if properties is None:
+        return text
+    style = next((node.get(namespace + 'val') for node in properties if node.tag == namespace + 'pStyle'), None)
+    outline = next((node.get(namespace + 'val') for node in properties if node.tag == namespace + 'outlineLvl'), None)
+    level = levels.get(style) or (int(outline) + 1 if outline and outline.isdigit() and int(outline) < 6 else 0)
+    if level:
+        return '#' * min(level, 6) + ' ' + text
+    numbering = next((node for node in properties if node.tag == namespace + 'numPr'), None)
+    if numbering is not None:
+        depth = next((node.get(namespace + 'val') for node in numbering if node.tag == namespace + 'ilvl'), '0')
+        return '  ' * (int(depth) if depth.isdigit() else 0) + '- ' + text
+    return text
+
+
+def _docx_table_lines(table, namespace):
+    """GFM table lines of a `w:tbl`: one row per `w:tr`, the first row as the header, cell text on one line."""
+    rows = []
+    for row in table:
+        if row.tag != namespace + 'tr':
+            continue
+        cells = []
+        for cell in row:
+            if cell.tag == namespace + 'tc':
+                text = ' '.join(' '.join(_docx_text(p, namespace).split()) for p in cell.iter(namespace + 'p'))
+                cells.append(' '.join(text.split()).replace('|', '\\|'))
+        if any(cells):
+            rows.append('| ' + ' | '.join(cells) + ' |')
+    if len(rows) > 1:
+        rows.insert(1, '|' + ' --- |' * (rows[0].count(' | ') + 1))
+    return rows
+
+
+def _docx_body_items(node, namespace):
+    """The paragraphs and tables of a body (or of a content control inside it) in document order."""
+    for child in node:
+        if child.tag in (namespace + 'p', namespace + 'tbl'):
+            yield child
+        elif child.tag == namespace + 'sdt':
+            for content in child:
+                if content.tag == namespace + 'sdtContent':
+                    yield from _docx_body_items(content, namespace)
+
+
+def docx_blocks(data):
+    """Markdown blocks of a .docx in document order, for reading: headings as `#`, list items as `- `, tables as GFM
+    tables, other paragraphs as text. Footnotes, endnotes and the distinct header and footer lines follow under
+    `## Notes` and `## Headers and footers`.
+
+    Parameters: data (the file bytes). Returns: a list of blocks (a block is a paragraph line or a whole table, lines
+    joined by newline). Raises: DocumentError with a readable reason for a corrupt, encrypted, oversized or hostile
+    package, or one without text."""
+    with _open_package(data, 'DOCX', 'word/document.xml') as package:
+        root = package.parse('word/document.xml')
+        namespace = _docx_namespace(root)
+        levels = _docx_heading_levels(package, namespace)
+        blocks = _Lines('DOCX')
+        body = next((node for node in root if node.tag == namespace + 'body'), root)
+        for item in _docx_body_items(body, namespace):
+            if item.tag == namespace + 'tbl':
+                table = _docx_table_lines(item, namespace)
+                if table:
+                    blocks.add('\n'.join(table))
+            else:
+                line = _docx_paragraph_line(item, namespace, levels)
+                if line:
+                    blocks.add(line)
+        notes, frame = [], []
+        for name in _docx_extra_parts(package):
+            part = package.parse(name)
+            target = frame if re.search(r'header|footer', name) else notes
+            for paragraph in part.iter(_docx_namespace(part) + 'p'):
+                text = ' '.join(_docx_text(paragraph, _docx_namespace(part)).split())
+                if text and text not in target:
+                    target.append(text)
+        if notes:
+            blocks.add('## Notes', *notes)
+        if frame:
+            blocks.add('## Headers and footers', *frame)
+    if not blocks:
+        raise DocumentError('DOCX has no text.')
+    return list(blocks)
+
+
 def _drawing_paragraphs(root):
     """Non-empty paragraphs (`a:p`) of a slide or notes part, from the `a:t` runs; the slide-number field is not text."""
     lines = []
@@ -173,26 +291,40 @@ def _drawing_paragraphs(root):
     return lines
 
 
-def extract_pptx(data):
-    """Text of a .pptx: each slide under `[slide N]`, then its speaker notes under `[notes N]`, in slide order.
+def pptx_slides(data):
+    """The slides of a .pptx in slide order, for extraction and for reading.
 
-    Parameters: data (the file bytes). Returns: UTF-8 text bytes. Raises: DocumentError with a readable reason for a
-    corrupt, encrypted, oversized or hostile package, or a deck without any text."""
+    Parameters: data (the file bytes). Returns: a list of `(number, body lines, notes lines)`, a slide without text
+    included with empty lists. Raises: DocumentError with a readable reason for a corrupt, encrypted, oversized or hostile
+    package or one over MAX_TEXT_BYTES of text."""
     def has_slides(names):
         return any(re.fullmatch(r'ppt/slides/slide\d+\.xml', name) for name in names)
 
     with _open_package(data, 'PPTX', has_slides) as package:
-        slides = sorted((int(m.group(1)), name) for name in package.entries
-                        if (m := re.fullmatch(r'ppt/slides/slide(\d+)\.xml', name)))
-        lines = _Lines('PPTX')
-        for number, name in slides:
+        numbered = sorted((int(m.group(1)), name) for name in package.entries
+                          if (m := re.fullmatch(r'ppt/slides/slide(\d+)\.xml', name)))
+        budget = _Lines('PPTX')
+        slides = []
+        for number, name in numbered:
             body = _drawing_paragraphs(package.parse(name))
-            if body:
-                lines.add(f'[slide {number}]', *body)
             notes_name = f'ppt/notesSlides/notesSlide{number}.xml'
             notes = _drawing_paragraphs(package.parse(notes_name)) if notes_name in package.entries else []
-            if notes:
-                lines.add(f'[notes {number}]', *notes)
+            budget.add(*body, *notes)
+            slides.append((number, body, notes))
+    return slides
+
+
+def extract_pptx(data):
+    """Text of a .pptx: each slide under `[slide N]`, then its speaker notes under `[notes N]`, in slide order.
+
+    Parameters: data (the file bytes). Returns: UTF-8 text bytes. Raises: DocumentError with a readable reason for a
+    corrupt, encrypted, oversized or hostile package, or a deck without any text."""
+    lines = _Lines('PPTX')
+    for number, body, notes in pptx_slides(data):
+        if body:
+            lines.add(f'[slide {number}]', *body)
+        if notes:
+            lines.add(f'[notes {number}]', *notes)
     if not lines:
         raise DocumentError('PPTX has no text.')
     return ('\n'.join(lines) + '\n').encode('utf-8')
@@ -264,14 +396,13 @@ def _sheet_rows(root, strings):
             yield '\t'.join(values)
 
 
-def extract_xlsx(data):
-    """Text of an .xlsx: each sheet, in workbook order, under `[sheet NAME]`, then one line per row with the cells
-    separated by tabs. Shared strings are resolved; numbers and inline strings are kept; a formula contributes its cached
-    value, nothing is calculated.
+def xlsx_sheets(data):
+    """The sheets of an .xlsx in workbook order, for extraction and for reading. Shared strings are resolved; numbers
+    and inline strings are kept; a formula contributes its cached value, nothing is calculated.
 
-    Parameters: data (the file bytes). Returns: UTF-8 text bytes. Raises: DocumentError with a readable reason for a
-    corrupt, encrypted, oversized or hostile package, a workbook over XLSX_MAX_ROWS rows or MAX_TEXT_BYTES of text, or
-    one without any text."""
+    Parameters: data (the file bytes). Returns: a list of `(name, rows)`, `rows` being the tab-joined text of each
+    non-empty row (empty for a sheet without text). Raises: DocumentError with a readable reason for a corrupt,
+    encrypted, oversized or hostile package, or a workbook over XLSX_MAX_ROWS rows or MAX_TEXT_BYTES of text."""
     with _open_package(data, 'XLSX', 'xl/workbook.xml') as package:
         workbook = package.parse('xl/workbook.xml')
         targets = {}
@@ -281,22 +412,40 @@ def extract_xlsx(data):
                 targets[rel.get('Id')] = posixpath.normpath(target.lstrip('/') if target.startswith('/')
                                                             else posixpath.join('xl', target))
         strings = _shared_strings(package)
-        lines = _Lines('XLSX')
-        rows = 0
+        budget = _Lines('XLSX')
+        sheets = []
+        total = 0
         for sheet in (node for node in workbook.iter() if _local(node.tag) == 'sheet'):
             rid = next((value for key, value in sheet.attrib.items() if _local(key) == 'id'), None)
             part = targets.get(rid)
             if part not in package.entries:
                 raise DocumentError('Invalid XLSX or excessive structure.')
-            header = f"[sheet {' '.join(sheet.get('name', '').split())}]"
+            name = ' '.join(sheet.get('name', '').split())
+            rows = []
             for line in _sheet_rows(package.parse(part), strings):
-                rows += 1
-                if rows > XLSX_MAX_ROWS:
+                total += 1
+                if total > XLSX_MAX_ROWS:
                     raise DocumentError(f'XLSX over {XLSX_MAX_ROWS} rows.')
-                if header:
-                    lines.add(header)
-                    header = ''
-                lines.add(line)
+                if not rows:
+                    budget.add(f'[sheet {name}]')
+                budget.add(line)
+                rows.append(line)
+            sheets.append((name, rows))
+    return sheets
+
+
+def extract_xlsx(data):
+    """Text of an .xlsx: each sheet, in workbook order, under `[sheet NAME]`, then one line per row with the cells
+    separated by tabs. Shared strings are resolved; numbers and inline strings are kept; a formula contributes its cached
+    value, nothing is calculated.
+
+    Parameters: data (the file bytes). Returns: UTF-8 text bytes. Raises: DocumentError with a readable reason for a
+    corrupt, encrypted, oversized or hostile package, a workbook over XLSX_MAX_ROWS rows or MAX_TEXT_BYTES of text, or
+    one without any text."""
+    lines = _Lines('XLSX')
+    for name, rows in xlsx_sheets(data):
+        if rows:
+            lines.add(f'[sheet {name}]', *rows)
     if not lines:
         raise DocumentError('XLSX has no text.')
     return ('\n'.join(lines) + '\n').encode('utf-8')
@@ -320,14 +469,15 @@ print(json.dumps({"pages": pages, "count": len(reader.pages)}))
 """
 
 
-def run_pdf(data, timeout, max_pages, max_chars):
-    """Text of a PDF (pypdf, pure Python), page by page, with `[page N]` markers. A hostile PDF can make pypdf parse for
-    minutes, so it runs in an isolated subprocess (`-I`) killed at the deadline.
+def pdf_pages(data, timeout, max_pages, max_chars):
+    """Text of each page of a PDF (pypdf, pure Python). A hostile PDF can make pypdf parse for minutes, so it runs in an
+    isolated subprocess (`-I`) killed at the deadline.
 
     Parameters: data (PDF bytes), timeout (seconds before the subprocess is killed), max_pages, max_chars (cap on the
-    text read, over all pages). Returns: the marked text, with a `[pages A-B not read]` line when a cap cut it; empty
-    pages are left out. Raises: PdfTimeout, PdfEncrypted (a password is needed), PdfUnreadable (corrupt; `detail` has
-    the last line pypdf reported), all DocumentError."""
+    text read, over all pages). Returns: `(pages, count)`: the text of the pages read (an empty string for a page
+    without text) and the page count of the file, which is larger when a cap cut the reading. Raises: PdfTimeout,
+    PdfEncrypted (a password is needed), PdfUnreadable (corrupt; `detail` has the last line pypdf reported), all
+    DocumentError."""
     try:
         done = subprocess.run([sys.executable, "-I", "-c", PDF_SCRIPT, str(max_pages), str(max_chars)],
                               input=data, capture_output=True, timeout=timeout,
@@ -341,11 +491,19 @@ def run_pdf(data, timeout, max_pages, max_chars):
         result = json.loads(done.stdout)
         if result.get("encrypted"):
             raise PdfEncrypted("PDF protected by a password.")
-        pages, count = result["pages"], result["count"]
+        return result["pages"], result["count"]
     except (ValueError, KeyError, AttributeError) as exc:
         if isinstance(exc, PdfEncrypted):
             raise
         raise PdfUnreadable("PDF could not be read.", f"unexpected extractor output ({type(exc).__name__})") from None
+
+
+def run_pdf(data, timeout, max_pages, max_chars):
+    """Text of a PDF through pdf_pages, with `[page N]` markers.
+
+    Parameters: as pdf_pages. Returns: the marked text, with a `[pages A-B not read]` line when a cap cut it; empty
+    pages are left out. Raises: as pdf_pages."""
+    pages, count = pdf_pages(data, timeout, max_pages, max_chars)
     text = "\n\n".join(f"[page {number}]\n{page}" for number, page in enumerate(pages, 1) if page)
     if count > len(pages):
         text += f"\n\n[pages {len(pages) + 1}-{count} not read]"

package/hook_decision.py

@@ -25,6 +25,7 @@ import index_scope
 import endpoint_sync
 import project_store
 import redirect_rule
+import requester
 import router
 import tool_redirect
 
@@ -298,6 +299,8 @@ def decide(payload, client, web_route, jobs):
             router.CLIENT.set(client)
             router.SESSION.set(payload.get("session_id"))
             router._log_decision(SMART_SEARCH_TOOL, {}, "allow", "Smart Tool search, logged to measure followed redirects")
+        requester.note_hook(payload["tool_name"].removeprefix(f"mcp__{SMART_TOOL_SERVER}__"), payload.get("tool_input"),
+                            payload.get("session_id"), payload.get("cwd"))
         return {}
     mode = config.hook_mode(cfg)
     if mode == "off" or not isinstance(payload, dict):
@@ -321,7 +324,12 @@ def _redirect(payload, client, plan, jobs):
     else runs as the agent wrote it and, in Claude Code, `after` swaps its output for the answer."""
     key, tool_name = payload["tool_use_id"], payload["tool_name"]
     tool_input = payload.get("tool_input") if isinstance(payload.get("tool_input"), dict) else {}
-    jobs.start(key, plan["kind"], plan["arguments"])
+    who = requester.CURRENT.set(requester.from_hook(client, payload)) if tool_name in WEB_TOOLS else None
+    try:
+        jobs.start(key, plan["kind"], plan["arguments"])
+    finally:
+        if who is not None:
+            requester.CURRENT.reset(who)
     if tool_name not in tool_redirect.NO_OP:
         return {}
     text = _answer(jobs, key, PRE_WAIT_S, tool_name)

package/lazy_mcp_proxy.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""Stdio MCP proxy that starts the real server only when a request needs it.
+
+Claude Code and Codex start every registered stdio server with the session, so a Playwright MCP server (Node, about
+97 MB of commit) sat idle in each session that never opened a browser. This proxy is what gets registered: it answers
+`initialize`, `ping` and `tools/list` from the handshake cache browser_control wrote after probing the real server, and
+starts the real command on the first other request (a tool call), replaying the client's `initialize` to it. From then
+on every message passes through unchanged. When the client closes stdin the real server's process tree is killed.
+
+Usage: lazy_mcp_proxy.py --handshake FILE -- COMMAND [ARG...]
+The cache (`{"initialize": <result>, "tools": [...]}`) missing or unreadable is an error on stderr and exit code 2, never
+an empty tool list.
+"""
+import json
+import os
+import queue
+import subprocess
+import sys
+import threading
+
+LAZY_ID = "smart-tool-lazy-init"
+INIT_TIMEOUT_S = 60
+KNOWN_PROTOCOLS = ("2024-11-05", "2025-03-26", "2025-06-18", "2025-11-25")
+_NO_WINDOW = getattr(subprocess, "CREATE_NO_WINDOW", 0)
+
+
+def load_handshake(path):
+    """The cached initialize result and tool list; RuntimeError when the file cannot be read or has the wrong shape."""
+    try:
+        with open(path, encoding="utf-8") as stream:
+            data = json.load(stream)
+        if not isinstance(data["initialize"], dict) or not isinstance(data["tools"], list):
+            raise TypeError("initialize must be an object and tools a list")
+    except (OSError, ValueError, KeyError, TypeError) as exc:
+        raise RuntimeError(f"handshake cache {path} is unusable ({type(exc).__name__}: {exc}); run browser_control.ensure "
+                           f"again (reinstall Smart Tool).") from exc
+    return data
+
+
+class Proxy:
+    """One client conversation: local answers until a request needs the real server, then a pass-through."""
+
+    def __init__(self, handshake, command, stdin, stdout):
+        self.handshake, self.command = handshake, command
+        self.stdin, self.stdout = stdin, stdout
+        self.child = None
+        self.closing = False
+        self.client_init = None
+        self.write_lock = threading.Lock()
+
+    def send(self, message):
+        """Writes one JSON-RPC message (dict) or one raw line (bytes) to the client."""
+        data = message if isinstance(message, bytes) else json.dumps(message, ensure_ascii=False).encode("utf-8") + b"\n"
+        with self.write_lock:
+            self.stdout.write(data)
+            self.stdout.flush()
+
+    def answer(self, request_id, result):
+        self.send({"jsonrpc": "2.0", "id": request_id, "result": result})
+
+    def local_initialize(self, params):
+        """The cached initialize result, speaking the protocol version the client asked for when it is a known one."""
+        result = dict(self.handshake["initialize"])
+        asked = (params or {}).get("protocolVersion")
+        if asked in KNOWN_PROTOCOLS:
+            result["protocolVersion"] = asked
+        return result
+
+    def start_child(self):
+        """Starts the real server and replays the client's initialize to it; its answer is not forwarded (the client
+        already got the cached one). RuntimeError when it exits or answers with an error."""
+        child = subprocess.Popen(self.command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=None,
+                                 creationflags=_NO_WINDOW)
+        params = self.client_init or {"protocolVersion": KNOWN_PROTOCOLS[2], "capabilities": {},
+                                      "clientInfo": {"name": "smart-tool-lazy-proxy", "version": "1"}}
+        child.stdin.write(json.dumps({"jsonrpc": "2.0", "id": LAZY_ID, "method": "initialize", "params": params}).encode()
+                          + b"\n")
+        child.stdin.flush()
+        answer = self.read_initialize(child)
+        if "error" in answer:
+            self.kill(child)
+            raise RuntimeError(f"the real server refused initialize: {answer['error']}")
+        child.stdin.write(b'{"jsonrpc":"2.0","method":"notifications/initialized"}\n')
+        child.stdin.flush()
+        self.child = child
+        threading.Thread(target=self.pump_child, args=(child,), daemon=True).start()
+
+    @classmethod
+    def read_initialize(cls, child):
+        """The real server's answer to the replayed initialize; RuntimeError (child killed) when it exits or stays silent
+        for INIT_TIMEOUT_S."""
+        answers = queue.Queue()
+
+        def read():
+            for line in child.stdout:
+                try:
+                    message = json.loads(line)
+                except ValueError:
+                    continue
+                if message.get("id") == LAZY_ID:
+                    answers.put(message)
+                    return
+            answers.put(None)
+        threading.Thread(target=read, daemon=True).start()
+        try:
+            answer = answers.get(timeout=INIT_TIMEOUT_S)
+        except queue.Empty:
+            cls.kill(child)
+            raise RuntimeError(f"the real server did not answer initialize in {INIT_TIMEOUT_S}s") from None
+        if answer is None:
+            raise RuntimeError(f"the real server exited before answering initialize (code {child.wait(10)})")
+        return answer
+
+    def pump_child(self, child):
+        """Child to client until the child closes its stdout; then the proxy exits with the child's code, loudly."""
+        for line in child.stdout:
+            self.send(line)
+        code = child.wait()
+        if self.closing:
+            return
+        print(f"lazy_mcp_proxy: the real server exited (code {code})", file=sys.stderr, flush=True)
+        os._exit(code or 1)
+
+    @staticmethod
+    def kill(child):
+        if child.poll() is not None:
+            return
+        if os.name == "nt":
+            subprocess.run(["taskkill", "/PID", str(child.pid), "/T", "/F"], capture_output=True, creationflags=_NO_WINDOW)
+        else:
+            child.kill()
+
+    def handle(self, line):
+        """One client line: answered here while the real server is not needed, else passed to it."""
+        try:
+            message = json.loads(line)
+        except ValueError:
+            print(f"lazy_mcp_proxy: invalid line ignored: {line[:200]!r}", file=sys.stderr, flush=True)
+            return
+        method, request_id = message.get("method"), message.get("id")
+        if method == "initialize":
+            self.client_init = message.get("params")
+        if self.child is None and request_id is not None and method == "initialize":
+            return self.answer(request_id, self.local_initialize(message.get("params")))
+        if self.child is None and request_id is not None and method == "ping":
+            return self.answer(request_id, {})
+        if self.child is None and request_id is not None and method == "tools/list":
+            return self.answer(request_id, {"tools": self.handshake["tools"]})
+        if self.child is None and (method is None or request_id is None):
+            return  # notifications and responses mean nothing to a server that is not running
+        if self.child is None:
+            try:
+                self.start_child()
+            except (OSError, RuntimeError) as exc:
+                self.send({"jsonrpc": "2.0", "id": request_id,
+                           "error": {"code": -32000, "message": f"could not start the server: {exc}"[:500]}})
+                return
+        self.child.stdin.write(line if line.endswith(b"\n") else line + b"\n")
+        self.child.stdin.flush()
+
+    def run(self):
+        for line in self.stdin:
+            if line.strip():
+                self.handle(line)
+        self.closing = True
+        if self.child is not None:
+            self.kill(self.child)
+
+
+def main(argv):
+    if "--" not in argv or argv[:1] != ["--handshake"] or len(argv) < 4:
+        print("usage: lazy_mcp_proxy.py --handshake FILE -- COMMAND [ARG...]", file=sys.stderr)
+        return 2
+    split = argv.index("--")
+    try:
+        handshake = load_handshake(argv[1])
+    except RuntimeError as exc:
+        print(f"lazy_mcp_proxy: {exc}", file=sys.stderr)
+        return 2
+    Proxy(handshake, argv[split + 1:], sys.stdin.buffer, sys.stdout.buffer).run()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allansantos-dev/smart-tool",
-  "version": "0.9.43",
+  "version": "0.9.45",
   "description": "Local MCP server that gives coding agents (Claude Code, Codex) cheaper, sharper tools than their built-in search. Windows.",
   "license": "Apache-2.0",
   "author": "Allan Santos",

package/requester.py

@@ -0,0 +1,76 @@
+"""Who asked for a web search or fetch, recorded next to each provider call and research job, never the query text.
+
+An MCP client only sends `clientInfo` (name, version) and the daemon's own `Mcp-Session-Id`: no session or folder. The
+PreToolUse hook of Claude Code does carry `session_id` and `cwd` before every tool call it matches, so the hook route
+notes them here (note_hook) and the MCP call that follows claims them by tool and arguments (claim). The first claim
+binds that MCP session to the Claude session and folder, so later calls of the same MCP session are attributed even
+when the hook did not fire for them. A client without that hook (Codex, or a Claude Code whose hook predates the
+web tools) leaves `session` and `project` empty and `source` says how far the attribution got.
+"""
+import collections
+import contextvars
+import json
+import threading
+import time
+
+WEB_TOOLS = ("web_search", "web_fetch")
+NOTE_TTL_S = 60
+MAX_NOTES = 256
+MAX_BOUND = 256
+
+CURRENT = contextvars.ContextVar("requester", default=None)
+_LOCK = threading.Lock()
+_NOTES = collections.OrderedDict()
+_BOUND = collections.OrderedDict()
+
+
+def _key(tool, arguments):
+    return tool + "\0" + json.dumps(arguments, sort_keys=True, ensure_ascii=False, default=str)
+
+
+def note_hook(tool, arguments, session_id, cwd):
+    """Remembers who the PreToolUse hook saw about to call `tool` with `arguments` (the MCP tool name without the
+    server prefix); claim() takes it back within NOTE_TTL_S."""
+    if tool not in WEB_TOOLS or not isinstance(arguments, dict):
+        return
+    entry = (time.monotonic(), session_id if isinstance(session_id, str) else None, cwd if isinstance(cwd, str) else None)
+    with _LOCK:
+        _NOTES.setdefault(_key(tool, arguments), collections.deque()).append(entry)
+        while len(_NOTES) > MAX_NOTES:
+            _NOTES.popitem(last=False)
+
+
+def claim(mcp_session, client, tool, arguments):
+    """The requester of one MCP tool call: {client, mcp_session, session, project, source}. source is `hook` when the
+    hook noted this very call, `mcp-session` when only an earlier call of the same MCP session was attributed, `none`
+    when the client gave nothing beyond its name."""
+    now = time.monotonic()
+    found = None
+    with _LOCK:
+        queue = _NOTES.get(_key(tool, arguments))
+        while queue and now - queue[0][0] > NOTE_TTL_S:
+            queue.popleft()
+        if queue:
+            found = queue.popleft()
+        if queue is not None and not queue:
+            del _NOTES[_key(tool, arguments)]
+        if found and mcp_session:
+            _BOUND[mcp_session] = (found[1], found[2])
+            while len(_BOUND) > MAX_BOUND:
+                _BOUND.popitem(last=False)
+        bound = _BOUND.get(mcp_session)
+    session, project = (found[1:] if found else bound) or (None, None)
+    return {"client": client or None, "mcp_session": (mcp_session or "")[:12] or None, "session": session,
+            "project": project, "source": "hook" if found else ("mcp-session" if bound else "none")}
+
+
+def from_hook(client, payload):
+    """The requester of a native WebSearch/WebFetch the hook is about to redirect: the payload itself names the session
+    and folder, no MCP call is involved."""
+    return {"client": client or None, "mcp_session": None, "session": payload.get("session_id"),
+            "project": payload.get("cwd"), "source": "hook"}
+
+
+def current():
+    """The requester of the tool call this thread (or a context copied from it) is serving, or None outside one."""
+    return CURRENT.get()