@allansantos-dev/smart-tool 0.9.43 → 0.9.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allansantos-dev/smart-tool",
-  "version": "0.9.43",
+  "version": "0.9.46",
   "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/projects_ui.py

@@ -1,13 +1,16 @@
 """Tela local de projetos; todas as operações passam pelos jobs do daemon."""
 import html
 import re
+import i18n
 import setup_ui
 import project_maps_ui
 import project_insights_ui
 
 
 def render_projects_page():
+    """The projects page with its token, map and insight components and the interface language script."""
     return (_PAGE.replace("__TOKEN__", html.escape(setup_ui.SETUP_TOKEN, quote=True))
+            .replace("__I18N__", i18n.page_script(setup_ui.SETUP_TOKEN))
             .replace("__MAP_STYLE__", project_maps_ui.STYLE)
             .replace("__MAP_HTML__", project_maps_ui.HTML)
             .replace("__MAP_SCRIPT__", project_maps_ui.SCRIPT)
@@ -24,13 +27,14 @@ def render_map_window():
         '__STYLE__': style.replace('__MAP_STYLE__', project_maps_ui.STYLE).replace('__INSIGHTS_STYLE__', project_insights_ui.STYLE),
         '__MAP_HTML__': project_maps_ui.HTML,
         '__MAP_SCRIPT__': project_maps_ui.SCRIPT,
+        '__I18N__': i18n.page_script(setup_ui.SETUP_TOKEN),
     }
     return re.sub('|'.join(re.escape(key) for key in values), lambda m:values[m[0]], _MAP_WINDOW)
 
 
 _MAP_WINDOW = r'''<!doctype html>
 <html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
-<meta name="setup-token" content="__TOKEN__"><title>Project maps · Smart Tool</title><style>
+<meta name="setup-token" content="__TOKEN__"><title>Project maps · Smart Tool</title>__I18N__<style>
 __STYLE__
 body.map-window{padding:0}.map-window header,.map-window main{max-width:none}.map-window header{padding:22px 28px 14px}.map-window main{padding:0 20px 30px}.map-window h1{font-size:22px}.map-window #window-root{margin:6px 0 0;font-size:12px;overflow-wrap:anywhere}.map-window .maps{margin-top:0}.map-window .maps>summary{display:none}.map-window .maps-workspace{grid-template-columns:minmax(0,1fr) 285px}.map-window #maps-svg{height:calc(100vh - 360px);min-height:430px}.map-window .maps-tools #maps-new-window{display:none}.map-window #maps-color-legend{max-height:90px}.map-window #window-message:empty{display:none}.map-window #window-message{margin-bottom:14px;overflow-wrap:anywhere}
 @media(max-width:850px){.map-window .maps-workspace{grid-template-columns:1fr}.map-window header{padding-inline:18px}.map-window main{padding-inline:12px}.map-window #maps-svg{height:450px;min-height:0}}
@@ -51,6 +55,7 @@ _PAGE = r'''<!doctype html>
 <html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
 <meta name="setup-token" content="__TOKEN__">
 <title>Projects and indexing · Smart Tool</title>
+__I18N__
 <style>
 :root{color-scheme:light dark;--bg:#f6f7f9;--surface:#fff;--border:#dde1e6;--ink:#1b2430;--muted:#5b6472;--accent:#2f6fed;--good:#18723c;--bad:#b52c2c;--warn:#805300;--selected:#eaf1ff}
 @media(prefers-color-scheme:dark){:root{--bg:#14171c;--surface:#1c2027;--border:#39414e;--ink:#e6e9ee;--muted:#a6afbb;--accent:#91baff;--good:#68dc93;--bad:#ff9696;--warn:#e0b565;--selected:#263751}}
@@ -96,7 +101,7 @@ function setAdd(open){const restore=$('add-form').contains(document.activeElemen
 function select(id){selected=id;scopeKey='';scopeDirty=false;window.SmartMaps?.reset();window.SmartInsights?.reset();history.replaceState(null,'','#'+id);render()}
 function jobsHtml(rows){return rows.map(j=>`<div class="job"><div class="job-line"><strong>${esc(kindNames[j.kind]||j.kind)}</strong><span class="state ${j.status==='error'?'bad':''}">${esc(states[j.status]||j.status)}</span></div>${j.message?`<p>${esc(j.cancel_requested?'Cancellation requested; waiting for the current call to finish.':j.message)}</p>`:''}${j.status==='pending'?`<progress aria-label="Indexing progress" ${j.total_files>0&&j.processed_files!=null?`max="${j.total_files}" value="${j.processed_files}"`:''}></progress>`:''}${j.error?`<p class="state bad">${esc(j.error)}</p>`:''}${j.warning?`<p>${esc(j.warning)}</p>`:''}<small>${esc(j.job_id)}${j.elapsed_s!=null?' · '+j.elapsed_s+' s':''}</small></div>`).join('')}
 function render(){
- $('count').textContent=projects.length+' folder'+(projects.length===1?' registered':'s registered');
+ $('count').textContent=projects.length===1?'1 folder registered':projects.length+' folders registered';
  const list=$('project-list');
  for(const node of [...list.children])if(!projects.some(p=>p.id===node.dataset.project))node.remove();
  for(const p of projects){let button=list.querySelector(`[data-project="${p.id}"]`);if(!button){button=document.createElement('button');button.className='project-item';button.dataset.project=p.id;button.append(document.createElement('strong'),document.createElement('small'));list.append(button)}button.setAttribute('aria-current',String(p.id===selected));button.firstChild.textContent=p.name;button.lastChild.textContent=(states[p.status]||p.status)+(p.watch&&!p.paused?' · Watching':'')}

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()

package/research_metrics.py

@@ -5,8 +5,9 @@ reaproveitamento, e `research_max_iterations` limita o retorno por rodada. Write
 `router-metrics.jsonl` — nada no daemon lê isto de volta; quem lê é
 `.token-guard/analyze_research.py`.
 
-Grava só o que a calibração usa: textos de consulta/tópico truncados e números. Nunca
-snippets nem páginas, que são conteúdo de terceiros e não ajudam a decidir o valor.
+Grava só o que a calibração usa: textos de consulta/tópico truncados e números, mais o
+`requester` (sessão e pasta de quem pediu, ver requester.py). Nunca snippets nem páginas,
+que são conteúdo de terceiros e não ajudam a decidir o valor.
 """
 import json
 import os
@@ -15,6 +16,7 @@ import threading
 import time
 
 import atomic_io
+import requester
 
 METRICS_PATH = os.path.join(paths.DATA_DIR, "research-metrics.jsonl")
 METRICS_MAX_BYTES = 2 * 1024 * 1024
@@ -34,7 +36,7 @@ def _short(text):
 
 
 def _append(record):
-    record = {"ts": time.time(), **record}
+    record = {"ts": time.time(), **({"requester": requester.current()} if requester.current() else {}), **record}
     try:
         line = json.dumps(record, ensure_ascii=False) + "\n"
         with _LOCK:

package/setup_audit.py

@@ -31,6 +31,7 @@ import yaml
 
 import atomic_io
 import endpoint_sync
+import i18n
 import paths
 
 REPORT_DIR = os.path.join(paths.DATA_DIR, "setup-audit")
@@ -904,13 +905,14 @@ def notices_due():
 
 
 def toast_text(row):
-    """(title, lines) of the toast for one `notices_due` row."""
+    """(title, lines) of the toast for one `notices_due` row, in the interface language."""
     total = row["errors"] + row["warnings"]
-    title = f"Setup audit: {total} new problem{'s' if total != 1 else ''} in the agent configuration"
+    title = (i18n.t("Setup audit: 1 new problem in the agent configuration") if total == 1
+             else i18n.t("Setup audit: {count} new problems in the agent configuration", count=total))
     lines = [os.path.basename(row["project"].rstrip("\\/")) or row["project"]]
     lines += [f"{item['severity']}: {item['check']} - {item['subject']}"[:120] for item in row["items"][:3]]
     if len(row["items"]) > 3:
-        lines.append(f"and {len(row['items']) - 3} more")
+        lines.append(i18n.t("and {count} more", count=len(row["items"]) - 3))
     return title, lines
 
 

package/setup_ui.py

@@ -28,6 +28,7 @@ import config
 import daemon_launcher
 import endpoint_sync
 import gateway
+import i18n
 import model_catalog
 import model_defaults
 import model_health
@@ -101,6 +102,7 @@ def render_setup_page():
         # Único valor que entra no corpo do HTML, e não no <script>: escapado porque vem
         # de variável de ambiente, ainda que só quem já executa código possa definí-la.
         "__SETUP_ORIGIN__": html.escape(setup_origin(), quote=True),
+        "__I18N__": i18n.page_script(SETUP_TOKEN),
     }
     # Um único passe sobre o template original: .replace() encadeado re-escanearia o
     # próprio resultado e corromperia o JSON se um valor coincidisse com o outro placeholder.
@@ -419,6 +421,16 @@ def handle_providers_save(body):
             "validated_results": validated}
 
 
+def handle_language_save(body):
+    """Saves the interface language the language button picked; returns {"language": <saved>}."""
+    if not isinstance(body, dict):
+        raise SetupError("Request body must be a JSON object with 'language'.")
+    try:
+        return {"language": i18n.set_language(body.get("language"))}
+    except ValueError as exc:
+        raise SetupError(str(exc)) from exc
+
+
 def handle_autostart_get():
     return autostart.status()
 
@@ -494,6 +506,7 @@ _PAGE_TEMPLATE = """<!doctype html>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>Settings · Smart Tool</title>
+__I18N__
 <style>
   :root { color-scheme: light dark;
     --bg: #f6f7f9; --surface: #ffffff; --line: #dde1e6; --ink: #1b2430; --muted: #5b6472; --soft: #eef1f5;
@@ -665,7 +678,7 @@ _PAGE_TEMPLATE = """<!doctype html>
 </head>
 <body>
 <header class="top">
-  <div><h1>Smart Tool settings</h1><span class="where">__SETUP_ORIGIN__ · version <span id="app-version"></span></span></div>
+  <div><h1>Smart Tool settings</h1><span class="where">__SETUP_ORIGIN__ · <span>Version</span> <span id="app-version"></span></span></div>
   <nav><a href="/projects">Projects and indexing →</a></nav>
 </header>
 <div class="shell">
@@ -1010,7 +1023,7 @@ function renderOverview() {
     badge.hidden = !entry;
     badge.textContent = entry ? entry.count : "";
     badge.dataset.tone = entry && entry.bad ? "bad" : "warn";
-    badge.title = entry ? plural(entry.count, "item") + (entry.count === 1 ? " needs" : " need") + " attention" : "";
+    badge.title = !entry ? "" : entry.count === 1 ? "1 item needs attention" : entry.count + " items need attention";
   }
 }
 

package/smart_tool_daemon.py

@@ -50,6 +50,7 @@ import indexer
 import index_views
 import index_inventory
 import usage_meter
+import document_read
 import document_text
 import dossier
 import scout
@@ -60,6 +61,7 @@ import project_identity
 import project_store
 import project_scheduler
 import project_monitor
+import requester
 import research_metrics
 import research_cache
 import router
@@ -350,7 +352,9 @@ SERVER_INSTRUCTIONS = (
     "project_manage action=affected_tests lists the tests to run. When smart_search returns nothing, retry smart_search with "
     "other terms; do not switch to Grep, Read of folders or shell search. To answer a question that would mean reading "
     "several files, call smart_scout: it reads them inside Smart Tool and returns only the lines that answer, as "
-    "path:lines with the literal text."
+    "path:lines with the literal text. To read a PDF, Word, PowerPoint or Excel file, call read_document (load it with "
+    "ToolSearch if it is not in your tool list): it returns the page count, size and estimated tokens first, then the "
+    "text of only the pages, slides or sheets you ask for, in far fewer tokens than the whole file."
 )
 
 TOOLS = [
@@ -540,6 +544,31 @@ TOOLS = [
             "required": ["url", "prompt"],
         },
     },
+    {
+        "name": "read_document",
+        "description": (
+            "Reads a PDF, Word (.docx), PowerPoint (.pptx) or Excel (.xlsx) file as compact text, a range at a time, "
+            "inside Smart Tool so the file never enters your context whole. The answer opens with the facts: type, "
+            "size, page, slide, sheet or part count and the estimated tokens of all the text; then comes the text of "
+            "the range you asked for (default: from the start, up to max_chars) with a `next:` line naming the range "
+            "to continue. PDF pages come with the layout noise removed (ligatures, hyphenation, wrapped lines); docx "
+            "as markdown (headings, lists, tables) in parts of about 6,000 characters because a docx has no fixed "
+            "pages; pptx per slide with the speaker notes; xlsx per sheet, one tab-separated line per row with the "
+            "cached formula values. Use info_only first to size a large file and pick the pages you need. A scanned "
+            "PDF (no text layer) fails with that reason; there is no OCR. Not for plain text or code: use Read."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "Absolute path of the .pdf, .docx, .pptx or .xlsx file"},
+                "range": {"type": "string", "description": "Pages, slides, docx parts or sheets to read: `3`, `3-5`, `7-` (to the end), `-4` (the first four) or a comma list like `1,4-6`; a sheet name also works for a workbook. Default: from the first one"},
+                "max_chars": {"type": "integer", "minimum": 1000, "maximum": document_read.MAX_CHARS_LIMIT, "default": document_read.DEFAULT_MAX_CHARS, "description": "Cap of the text returned (about four characters per token)"},
+                "info_only": {"type": "boolean", "default": False, "description": "Return only the facts (type, size, counts, estimated tokens), no text"},
+            },
+            "required": ["path"],
+            "additionalProperties": False,
+        },
+    },
     {
         "name": "web_search_result",
         "_meta": ALWAYS_LOAD,
@@ -2615,14 +2644,15 @@ def _fan_out_web_search(query, num, budget_s=None, site_domains=()):
     for tier_name in web_search_adapters.FAN_OUT_TIERS:
         fut = WEB_SEARCH_EXECUTOR.submit(_run_tier, tier_name, query, num)
         futures[fut] = tier_name
+    who = requester.current()  # the callbacks run in the pool's threads, outside this request's context
 
     def _record_on_done(tier_name):
         def _cb(fut):
             try:
                 fut.result()
-                _record_tier_health(tier_name, success=True)
+                _record_tier_health(tier_name, success=True, who=who)
             except Exception as exc:
-                _record_tier_failure(tier_name, exc)
+                _record_tier_failure(tier_name, exc, who)
         return _cb
 
     for fut, tier_name in futures.items():
@@ -2690,7 +2720,7 @@ def _handle_web_search_body(arguments):
         job_id = uuid.uuid4().hex
         _set_job(job_id, status="pending", result=None, error=None, created_at=time.time())
         try:
-            DEEP_JOB_EXECUTOR.submit(_run_deep_job, job_id, query, scope)
+            DEEP_JOB_EXECUTOR.submit(contextvars.copy_context().run, _run_deep_job, job_id, query, scope)
         except Exception as exc:
             # Se o submit() em si falhar (pool fechado/saturado), o job já foi
             # registrado como "pending" — sem isto, ficaria assim pra sempre,
@@ -2702,7 +2732,7 @@ def _handle_web_search_body(arguments):
         job_id = uuid.uuid4().hex
         _set_job(job_id, status="pending", result=None, error=None, created_at=time.time())
         try:
-            RESEARCH_JOB_EXECUTOR.submit(_run_research_job, job_id, query, num, scope)
+            RESEARCH_JOB_EXECUTOR.submit(contextvars.copy_context().run, _run_research_job, job_id, query, num, scope)
         except Exception as exc:
             _set_job(job_id, status="error", result=None, error=_sanitize_text(f"{type(exc).__name__}: {exc}"), created_at=time.time())
         return _to_json_sanitized({"job_id": job_id, "status": "pending"})
@@ -3210,14 +3240,14 @@ def _annotate_quick_results(rows, classification, cache=None):
     return result
 
 
-def _record_tier_health(tier_name, success, outcome=None):
+def _record_tier_health(tier_name, success, outcome=None, who=None):
     try:
-        web_search_health.record(tier_name, success, outcome)
+        web_search_health.record(tier_name, success, outcome, who or requester.current())
     except Exception:
         pass  # telemetria é best-effort — nunca pode derrubar uma busca já resolvida
 
 
-def _record_tier_failure(tier_name, exc):
+def _record_tier_failure(tier_name, exc, who=None):
     """Health entry for a failed tier call, keeping a 429, a captcha and a quota pause apart from other errors."""
     if isinstance(exc, (TierSkipped, browser_service_client.BrowserSkipped)):
         outcome = "paused"
@@ -3227,7 +3257,7 @@ def _record_tier_failure(tier_name, exc):
         outcome = "captcha"
     else:
         outcome = "failed"
-    _record_tier_health(tier_name, False, outcome)
+    _record_tier_health(tier_name, False, outcome, who)
 
 
 _is_safe_crawl_target = web_fetch.is_safe_target
@@ -3979,7 +4009,29 @@ def _session_audit_hook(handler):
     return output
 
 
+def _handle_read_document(arguments):
+    """read_document: facts and a page, slide, sheet or part range of a PDF, docx, pptx or xlsx as compact text (see
+    document_read). Fails loudly, with the reason, for a path that is not absolute or readable, an unsupported or
+    oversized file, a password, a scanned PDF, a corrupt or hostile package and a range outside the document; one metric
+    row records the kind, the estimated tokens of the whole text and of the answer."""
+    started = time.monotonic()
+    unknown = sorted(set(arguments) - {"path", "range", "max_chars", "info_only"})
+    if unknown:
+        raise ValueError(f"read_document does not take {', '.join(unknown)}")
+    try:
+        text = document_read.read(arguments.get("path"), arguments.get("range") or None,
+                                  arguments.get("max_chars", document_read.DEFAULT_MAX_CHARS),
+                                  bool(arguments.get("info_only")))
+    except Exception as exc:
+        _metric("read_document", error=type(exc).__name__, elapsed_s=round(time.monotonic() - started, 2))
+        raise
+    _metric("read_document", kind=os.path.splitext(str(arguments.get("path")))[1].lower(),
+            answer_tokens=document_read.estimate_tokens(text), elapsed_s=round(time.monotonic() - started, 2))
+    return _sanitize_text(text)
+
+
 _TOOL_HANDLERS = {
+    "read_document": _handle_read_document,
     "web_fetch": _handle_web_fetch,
     "project_manage": _handle_project_manage,
     "smart_search": _handle_smart_search,
@@ -4002,7 +4054,8 @@ def _metric(event, **fields):
     _session, client = _session_client()
     try:
         integration_metrics.record(event, client=client_hooks.identify(client) or client.get("name"),
-                                   client_version=client.get("version"), **fields)
+                                   client_version=client.get("version"),
+                                   **({"requester": requester.current()} if requester.current() else {}), **fields)
     except (OSError, ValueError) as exc:
         _log(f"integration metric not saved: {exc}")
 
@@ -4016,6 +4069,9 @@ def _dispatch_tool_call(params, session_id=None):
     if handler is None:
         return _tool_result(_sanitize_text(f"Unknown tool: {name}"), is_error=True)
     token = _MCP_SESSION.set(session_id)
+    who = None
+    if name in requester.WEB_TOOLS:
+        who = requester.CURRENT.set(requester.claim(session_id, _session_client()[1].get("name"), name, arguments))
     try:
         with model_health.tool_call(name) as failures:
             try:
@@ -4031,6 +4087,8 @@ def _dispatch_tool_call(params, session_id=None):
             result["content"][0]["text"] += _sanitize_text(warning)
         return result
     finally:
+        if who is not None:
+            requester.CURRENT.reset(who)
         _MCP_SESSION.reset(token)
 
 
@@ -4105,6 +4163,7 @@ _SETUP_SAVES = {
     "/setup/gateway": setup_ui.handle_gateway_save,
     "/setup/autostart": setup_ui.handle_autostart_action,
     "/setup/contact": setup_ui.handle_contact_save,
+    "/setup/language": setup_ui.handle_language_save,
     "/setup/audit": setup_ui.handle_audit,
 }
 

package/toast_notice.py

@@ -74,13 +74,14 @@ def action_uri(action, **params):
 
 
 def toast_xml(title, lines, buttons):
-    """`buttons` is a list of (label, uri); each one launches its protocol link and closes the toast."""
+    """`buttons` is a list of (label, uri); each one launches its protocol link and closes the toast. An empty list
+    gives a toast without an actions element."""
     text = "".join(f"<text>{escape(line)}</text>" for line in [title, *lines])
     actions = "".join(
         f'<action content={quoteattr(label)} arguments={quoteattr(uri)} activationType="protocol"/>'
         for label, uri in buttons)
     return (f'<toast><visual><binding template="ToastGeneric">{text}</binding></visual>'
-            f'<actions>{actions}</actions></toast>')
+            + (f'<actions>{actions}</actions>' if actions else '') + '</toast>')
 
 
 def show(title, lines, buttons, tag=None):

package/tool_redirect.py

@@ -10,6 +10,7 @@ the PreToolUse is rewritten to a no-op that always succeeds (a grep with no matc
 replacement: its shell call is rewritten to print a file holding the answer, which Codex only applies with `allow`.
 """
 import concurrent.futures
+import contextvars
 import os
 import threading
 import time
@@ -40,7 +41,7 @@ class Jobs:
             for old in [k for k, (at, _f) in self._futures.items() if now - at > RESULT_TTL_S]:
                 del self._futures[old]
             if key not in self._futures:
-                self._futures[key] = (now, _POOL.submit(self._runners[kind], arguments))
+                self._futures[key] = (now, _POOL.submit(contextvars.copy_context().run, self._runners[kind], arguments))
 
     def wait(self, key, timeout):
         """The text of key's call when it finished within timeout seconds, else None (the call keeps running and a