@allansantos-dev/smart-tool 0.9.39 → 0.9.41

package/setup_ui.py

@@ -201,11 +201,13 @@ def handle_health_get():
 
 
 def handle_notices():
-    """What the tray should show now: the model offer (once a day until answered) and models over the failure limit
-    (once a day each). Fetching marks them announced, so each toast is shown once per reminder period."""
+    """What the tray should show now: the model offer (once a day until answered), models over the failure limit
+    (once a day each) and the new errors or warnings of the scheduled setup audit (once per finding). Fetching marks
+    them announced, so each toast is shown once per reminder period."""
     upgrade = _checked_upgrade()
     offer = model_upgrade.due() if upgrade["state"] == "pending" else None
-    return {"upgrade": offer, "failing": model_health.alerts_due(), "check_error": upgrade["check_error"]}
+    return {"upgrade": offer, "failing": model_health.alerts_due(), "audit": setup_audit.notices_due(),
+            "check_error": upgrade["check_error"]}
 
 
 def handle_local_models_get():
@@ -253,6 +255,10 @@ def handle_integration_get():
         duplicate_mode, duplicate_error = config.duplicate_mode(), ""
     except ValueError as exc:
         duplicate_mode, duplicate_error = "", str(exc)
+    try:
+        dependency_mode, dependency_error = config.dependency_mode(), ""
+    except ValueError as exc:
+        dependency_mode, dependency_error = "", str(exc)
     try:
         proposals_mode, proposals_error = config.pattern_proposals(), ""
     except ValueError as exc:
@@ -265,6 +271,8 @@ def handle_integration_get():
             "hook_modes": list(config.HOOK_MODES), "doc_mode": doc_mode, "doc_mode_error": doc_error,
             "doc_modes": list(config.DOC_MODES), "duplicate_mode": duplicate_mode,
             "duplicate_mode_error": duplicate_error, "duplicate_modes": list(config.DUPLICATE_MODES),
+            "dependency_mode": dependency_mode, "dependency_mode_error": dependency_error,
+            "dependency_modes": list(config.DEPENDENCY_MODES),
             "pattern_proposals": proposals_mode, "pattern_proposals_error": proposals_error,
             "block_patterns": {"proposals": stored["proposals"], "accepted": stored["accepted"],
                                "rejected": len(stored["rejected"]), "error": patterns_error},
@@ -283,10 +291,11 @@ def handle_integration_save(body):
         except (OSError, ValueError) as exc:
             raise SetupError(str(exc))
         return handle_integration_get()
-    if isinstance(body, dict) and body.get("action") in ("hook_mode", "doc_mode", "duplicate_mode", "pattern_proposals"):
+    if isinstance(body, dict) and body.get("action") in ("hook_mode", "doc_mode", "duplicate_mode", "dependency_mode", "pattern_proposals"):
         action = body["action"]
         allowed = {"hook_mode": config.HOOK_MODES, "doc_mode": config.DOC_MODES,
-                   "duplicate_mode": config.DUPLICATE_MODES, "pattern_proposals": config.PATTERN_PROPOSAL_MODES}[action]
+                   "duplicate_mode": config.DUPLICATE_MODES, "dependency_mode": config.DEPENDENCY_MODES,
+                   "pattern_proposals": config.PATTERN_PROPOSAL_MODES}[action]
         if body.get("mode") not in allowed:
             raise SetupError(f"Invalid mode: use {', '.join(allowed)}.")
         try:
@@ -738,7 +747,7 @@ _PAGE_TEMPLATE = """<!doctype html>
 
       <div class="card" id="health-card">
         <div class="card-head"><h3>Model failures (last 24 h)</h3><span class="pill" id="health-pill" data-tone="busy">Checking</span></div>
-        <p class="lede">Every failed call to a gateway model, by role and tool. A model that fails half of its calls (5 or more) also raises a Windows notification.</p>
+        <p class="lede">Failed calls to a gateway model, grouped by type (429, 503, timeout, ...) and role, with the latest lines of each group. A model that fails half of its calls (5 or more) also raises a Windows notification.</p>
         <div id="health-table"></div>
       </div>
 
@@ -1151,15 +1160,29 @@ for (const [id, action] of [["btn-upgrade-apply", "apply"], ["btn-upgrade-declin
     }
   });
 }
+const FAILURE_TYPES = { "429": "429 Too Many Requests", "503": "503 Service Unavailable", "5xx": "Other 5xx", timeout: "Timeout",
+  connection: "Connection", auth: "Authentication (401/403)", other: "Other" };
+const PURPOSE_LABELS = { index_embedding: "Indexing", query_embedding: "Query", rerank: "Rerank", embedding_probe: "Model check", scope: "Scope" };
+function healthHtml(data) {
+  const when = (at) => esc(new Date(at * 1000).toLocaleString());
+  const models = data.models.map((row) => `<tr><td>${esc(row.role)}</td><td>${esc(row.model)}</td><td>${row.errors} / ${row.calls}</td><td>${Math.round(row.rate * 100)}%</td></tr>`).join("");
+  const purposes = data.calls_by_purpose.map((row) => `<tr><td>${esc(PURPOSE_LABELS[row.purpose] || row.purpose)}</td><td>${row.attempts}</td><td>${row.errors}</td></tr>`).join("");
+  const groups = data.groups.map((group) => {
+    const rows = group.rows.map((row) => `<tr><td>${when(row.at)}</td><td>${esc(row.model)}</td><td>${esc(row.tool || "-")}</td><td>${esc(row.error)}</td></tr>`).join("");
+    return `<details class="more health-group" data-type="${esc(group.type)}"><summary>${esc(FAILURE_TYPES[group.type] || group.type)} · ${esc(group.role)} · ${plural(group.count, "failure")} · ${when(group.first_at)} to ${when(group.last_at)}</summary>`
+      + `<p class="mono">${esc(group.sample)}</p><table><tr><th>When</th><th>Model</th><th>Tool</th><th>Error</th></tr>${rows}</table>`
+      + (group.count > group.rows.length ? `<p>Showing the latest ${group.rows.length} of ${group.count}.</p>` : "") + "</details>";
+  }).join("");
+  return (models ? `<table><tr><th>Role</th><th>Model</th><th>Failed / calls</th><th>Rate</th></tr>${models}</table>` : "<p>No model call in the last 24 hours.</p>")
+    + (purposes ? `<h4>Calls by purpose</h4><table><tr><th>Purpose</th><th>Calls</th><th>Failed</th></tr>${purposes}</table>` : "")
+    + (groups ? `<h4>Failures by type</h4>${groups}` : "");
+}
 async function loadHealth() {
   try {
     const data = await getJSON("/setup/models/health");
     const failing = data.models.filter((row) => row.failing).length;
     setPill("health-pill", failing ? "bad" : "ok", failing ? plural(failing, "model") + " failing" : "No problem");
-    const models = data.models.map((row) => `<tr><td>${esc(row.role)}</td><td>${esc(row.model)}</td><td>${row.errors} / ${row.calls}</td><td>${Math.round(row.rate * 100)}%</td></tr>`).join("");
-    const failures = data.failures.map((row) => `<tr><td>${esc(new Date(row.at * 1000).toLocaleString())}</td><td>${esc(row.role)}</td><td>${esc(row.model)}</td><td>${esc(row.tool || "-")}</td><td>${esc(row.error)}</td></tr>`).join("");
-    $("health-table").innerHTML = (models ? `<table><tr><th>Role</th><th>Model</th><th>Failed / calls</th><th>Rate</th></tr>${models}</table>` : "<p>No model call in the last 24 hours.</p>")
-      + (failures ? `<table><tr><th>When</th><th>Role</th><th>Model</th><th>Tool</th><th>Error</th></tr>${failures}</table>` : "");
+    $("health-table").innerHTML = healthHtml(data);
   } catch (error) {
     setPill("health-pill", "bad", "Unavailable");
     $("health-table").textContent = "Could not read the failure log: " + error.message;
@@ -1268,6 +1291,10 @@ const RULES = [
     intro: "Compares the functions an edit writes with the indexed code: identical bodies, and near-identical ones with only local names changed. It never blocks.",
     options: [["warn", "Warn", "The edit runs; the agent is told when a function copies one already in the project.", true],
               ["off", "Off", "No duplicate checks."]] },
+  { key: "dependency_mode", title: "Vulnerable dependencies on edit", applies: "Applies on the next edit.",
+    intro: "Looks up the dependencies an edit of a dependency manifest adds or changes in the OSV advisory database. It never blocks.",
+    options: [["warn", "Warn", "The edit runs; the agent is told which added or changed dependencies have known advisories.", true],
+              ["off", "Off", "No dependency checks and no network call."]] },
   { key: "pattern_proposals", title: "Block patterns proposed by a model", applies: "Applies to the next review.",
     intro: "Afterwards, never delaying a call, the scope model (else the router model) reviews searches the fixed rule let through and may propose block patterns. Nothing blocks until you accept it on the Redirects page.",
     options: [["on", "On", "Review in the background and list proposals for you.", true],

package/smart_tool_daemon.py

@@ -529,7 +529,7 @@ TOOLS = [
         "description": (
             "Reads a known URL and returns only the answer to the prompt, written by the gateway's mini model - use instead of "
             "the native WebFetch. The page is cached for 24 h: another prompt on the same URL does not download it again. "
-            "JavaScript-built pages are rendered in the browser. Does not read localhost, internal networks or PDFs."
+            "JavaScript-built pages are rendered in the browser. Reads PDFs as text, page by page; does not read localhost or internal networks."
         ),
         "inputSchema": {
             "type": "object",
@@ -676,69 +676,97 @@ def _embed_retry_delay(exc, attempt):
     return min(8, 2 ** (attempt - 1)) + random.uniform(0, .25)
 
 
+def _wait_to_retry(exc, attempt, deadline=None, cancel_check=None):
+    """Sleeps the wait the gateway asked for (`Retry-After`, else exponential with jitter) before the next attempt;
+    raises TimeoutError when that wait does not fit in `deadline`."""
+    delay = _embed_retry_delay(exc, attempt)
+    if deadline is not None and delay >= _research_time_left(deadline):
+        raise TimeoutError("Not enough time left to honor the gateway backoff.")
+    if cancel_check:
+        until = time.monotonic() + delay
+        while time.monotonic() < until:
+            cancel_check()
+            time.sleep(min(.2, max(0, until - time.monotonic())))
+    else:
+        time.sleep(delay)
+
+
+def _embed_request(model, batch, token, deadline=None, on_retry=None, cancel_check=None):
+    """Vectors of one embeddings request in input order, repeating a transient failure up to EMBED_MAX_ATTEMPTS times."""
+    for attempt in range(1, EMBED_MAX_ATTEMPTS + 1):
+        if cancel_check:
+            cancel_check()
+        timeout = (min(EMBED_REQUEST_TIMEOUT_S, _research_time_left(deadline))
+                   if deadline is not None else EMBED_REQUEST_TIMEOUT_S)
+        try:
+            response = model_client.fetch(
+                "/v1/embeddings", token, method="POST", body={"model": model, "input": batch},
+                timeout=timeout,
+            )
+        except Exception as exc:
+            if attempt >= EMBED_MAX_ATTEMPTS or not _transient_embed_error(exc):
+                raise
+            if on_retry:
+                on_retry(attempt + 1, len(batch))
+            _wait_to_retry(exc, attempt, deadline, cancel_check)
+            continue
+        if cancel_check:
+            cancel_check()
+        rows = response.get("data", []) if isinstance(response, dict) else []
+        if not isinstance(rows, list) or len(rows) != len(batch):
+            raise RuntimeError("The gateway returned a different number of embeddings than the input.")
+        ordered = [None] * len(batch)
+        for row in rows:
+            if not isinstance(row, dict):
+                raise indexer.IndexVectorError("Invalid embedding row.")
+            idx = row.get("index", 0 if len(batch) == 1 else None)
+            if type(idx) is not int or not 0 <= idx < len(batch) or ordered[idx] is not None:
+                raise indexer.IndexVectorError("Embedding indexes missing, duplicated or outside the batch.")
+            ordered[idx] = row.get("embedding")
+        return ordered
+
+
 def _embed(model, texts, token, deadline=None, on_retry=None, cancel_check=None):
+    """One vector per text. A request the gateway refuses for its size (HTTP 400 or 413) is split in two halves, each
+    sent once; a half that is refused again raises."""
     if local_embedder.is_local(model):
         return local_embedder.embed(model, texts, deadline=deadline, cancel_check=cancel_check, on_retry=on_retry)
     vectors = []
     dimensions = None
     for batch in _embed_batches(texts):
-        max_attempts = EMBED_MAX_ATTEMPTS if deadline is None or on_retry is not None else 1
-        for attempt in range(1, max_attempts + 1):
-            if cancel_check:
-                cancel_check()
-            timeout = (min(EMBED_REQUEST_TIMEOUT_S, _research_time_left(deadline))
-                       if deadline is not None else EMBED_REQUEST_TIMEOUT_S)
-            try:
-                response = model_client.fetch(
-                    "/v1/embeddings", token, method="POST", body={"model": model, "input": batch},
-                    timeout=timeout,
-                )
-            except Exception as exc:
-                if attempt >= max_attempts or not _transient_embed_error(exc):
-                    raise
-                if on_retry:
-                    on_retry(attempt + 1, len(batch))
-                delay = _embed_retry_delay(exc, attempt)
-                if deadline is not None and delay >= _research_time_left(deadline):
-                    raise TimeoutError("Not enough time left to honor the gateway backoff.")
-                if cancel_check:
-                    until = time.monotonic() + delay
-                    while time.monotonic() < until:
-                        cancel_check()
-                        time.sleep(min(.2, max(0, until - time.monotonic())))
-                else:
-                    time.sleep(delay)
-                continue
-            if cancel_check:
-                cancel_check()
-            rows = response.get("data", []) if isinstance(response, dict) else []
-            if not isinstance(rows, list) or len(rows) != len(batch):
-                raise RuntimeError("The gateway returned a different number of embeddings than the input.")
-            ordered = [None] * len(batch)
-            for row in rows:
-                if not isinstance(row, dict):
-                    raise indexer.IndexVectorError("Invalid embedding row.")
-                idx = row.get("index", 0 if len(batch) == 1 else None)
-                if type(idx) is not int or not 0 <= idx < len(batch) or ordered[idx] is not None:
-                    raise indexer.IndexVectorError("Embedding indexes missing, duplicated or outside the batch.")
-                vector = row.get("embedding")
-                dimensions = indexer.validate_vector(vector, dimensions)
-                ordered[idx] = vector
-            vectors.extend(ordered)
-            break
+        try:
+            ordered = _embed_request(model, batch, token, deadline, on_retry, cancel_check)
+        except urllib.error.HTTPError as exc:
+            if exc.code not in (400, 413) or len(batch) < 2:
+                raise
+            half = len(batch) // 2
+            ordered = (_embed_request(model, batch[:half], token, deadline, on_retry, cancel_check)
+                       + _embed_request(model, batch[half:], token, deadline, on_retry, cancel_check))
+        for vector in ordered:
+            dimensions = indexer.validate_vector(vector, dimensions)
+        vectors.extend(ordered)
     return vectors
 
 
 def _rerank(model, query, documents, top_n, token, deadline=None):
+    """Rows `{index, relevance_score}` of the best `top_n` documents. Only an HTTP answer that is worth repeating
+    (429, 5xx) is asked again, after the wait of `_wait_to_retry`; a timeout fails at once so a search does not stall."""
     if not documents:
         return []
     top_n = min(top_n, len(documents))
-    timeout = min(15, _research_time_left(deadline)) if deadline is not None else 15
-    response = model_client.fetch(
-        "/v1/rerank", token, method="POST",
-        body={"model": model, "query": query, "documents": documents, "top_n": top_n},
-        timeout=timeout,
-    )
+    for attempt in range(1, EMBED_MAX_ATTEMPTS + 1):
+        timeout = min(15, _research_time_left(deadline)) if deadline is not None else 15
+        try:
+            response = model_client.fetch(
+                "/v1/rerank", token, method="POST",
+                body={"model": model, "query": query, "documents": documents, "top_n": top_n},
+                timeout=timeout,
+            )
+            break
+        except urllib.error.HTTPError as exc:
+            if attempt >= EMBED_MAX_ATTEMPTS or not _transient_embed_error(exc):
+                raise
+            _wait_to_retry(exc, attempt, deadline)
     rows = response.get("results", []) if isinstance(response, dict) else []
     if not isinstance(rows, list) or not rows:
         raise ValueError("The reranker returned no valid results.")
@@ -1054,7 +1082,9 @@ def _prepare_project_index(arguments, job_id, cfg, token, query_vector=None, pre
         return result
     model = model or local_embedder.resolve(cfg.get("embedding_model"), indexer.info(root).get("model_id"))
     lexical = model == indexer.LEXICAL_MODEL
-    if not lexical and query_vector is None:
+    current = indexer.info(root)
+    known_dimensions = current.get("dimensions") if current.get("model_id") == model else None
+    if not lexical and query_vector is None and not known_dimensions:
         _update_job(job_id, phase="model_probe")
         query_vector = _embed(model, ["Smart Tool: indexing dimension check."], token,
                               deadline=_job_deadline(job_id), cancel_check=checkpoint,
@@ -1062,7 +1092,6 @@ def _prepare_project_index(arguments, job_id, cfg, token, query_vector=None, pre
                                   retry_attempt=attempt, batch_items=items))[0]
     checkpoint()
     _update_job(job_id, phase="indexing")
-    current = indexer.info(root)
     full_check = bool(arguments.get("full_check") or project.get("needs_full_check") or
                       time.time() - current.get("full_scan_at", 0) >= project_monitor.FULL_CHECK_S)
     stats = indexer.reindex(
@@ -1072,7 +1101,7 @@ def _prepare_project_index(arguments, job_id, cfg, token, query_vector=None, pre
                                  job_id, phase="indexing_retry", retry_attempt=attempt, batch_items=items)),
         on_progress=lambda processed, total: _update_job(
             job_id, phase="indexing", processed_files=processed, total_files=total),
-        model_id=model, expected_dimensions=None if lexical else len(query_vector),
+        model_id=model, expected_dimensions=None if lexical else known_dimensions or len(query_vector),
         force_rebuild=bool(arguments.get("force_rebuild")), full_check=full_check,
         changed_paths=set(arguments.get("changed_paths") or []) | set(project.get('dirty_paths', [])), cancel_check=checkpoint,
     )
@@ -1110,6 +1139,33 @@ LEXICAL_WARNING = ("No embedding model: index and search are lexical only (exact
                    "Configure an embedding_model for semantic search.")
 
 
+def _rerank_blocks(model, groups, queries, found, vectors, token, deadline=None):
+    """`({group: rows}, {group: error})` of the blocks that have candidates and a query vector. One rerank request goes
+    out per distinct query, not per block: the candidates of the blocks that share a query travel together and come back
+    split by block (`index` is the position inside the block's candidates). A reranker scores each document against the
+    query on its own, so a block gets the order and scores a request of its own would give."""
+    ranked, failed = {}, {}
+    by_query = {}
+    for group in groups:
+        if found[group] and vectors.get(queries[group]) is not None:
+            by_query.setdefault(queries[group], []).append(group)
+    for query, members in by_query.items():
+        owners = [(group, position) for group in members for position in range(len(found[group]))]
+        documents = [found[group][position][4] for group, position in owners]
+        try:
+            rows = _rerank(model, query, documents, len(documents), token, deadline=deadline)
+        except Exception as exc:
+            failed.update({group: _project_error(exc) for group in members})
+            continue
+        ranked.update({group: [] for group in members})
+        for row in rows:
+            group, position = owners[row["index"]]
+            ranked[group].append({"index": position, "relevance_score": row["relevance_score"]})
+        failed.update({group: "ValueError: The reranker returned no result for this block."
+                       for group in members if not ranked[group]})
+    return ranked, failed
+
+
 def _perform_smart_search(arguments, job_id):
     return contextvars.copy_context().run(_perform_smart_search_isolated, arguments, job_id)
 
@@ -1220,22 +1276,22 @@ def _perform_smart_search_isolated(arguments, job_id):
                                    include=lambda path, group=group: index_profile.kind(path, profile) == group)
              for group in groups}
 
+    reranked, rerank_failed = {}, {}
+    if cfg.get("rerank_model"):
+        _update_job(job_id, phase="reranking")
+        reranked, rerank_failed = _rerank_blocks(cfg["rerank_model"], groups, queries, found, vectors, token,
+                                                 deadline=_job_deadline(job_id))
+
     def search_block(group):
         top_k = limits[group]
         query, vector, candidates = queries[group], vectors.get(queries[group]), found[group]
         ordered = [(score, "hybrid" if vector is not None else "lexical", row) for score, *row in candidates[:top_k]]
         problem = None
-        if cfg.get("rerank_model") and candidates and vector is not None:
-            _update_job(job_id, phase="reranking")
-            try:
-                reranked = _rerank(cfg["rerank_model"], query, [c[4] for c in candidates], top_k, token,
-                                   deadline=_job_deadline(job_id))
-                if not reranked or any(type(item.get("index")) is not int or not 0 <= item["index"] < len(candidates)
-                                       for item in reranked):
-                    raise ValueError("Invalid index in the reranker response.")
-                ordered = [(float(item["relevance_score"]), "rerank", candidates[item["index"]][1:]) for item in reranked]
-            except Exception as exc:
-                problem = f"Rerank unavailable for {group}; hybrid lexical/vector order kept. " + _project_error(exc)
+        if group in rerank_failed:
+            problem = f"Rerank unavailable for {group}; hybrid lexical/vector order kept. " + rerank_failed[group]
+        elif group in reranked:
+            ordered = [(float(item["relevance_score"]), "rerank", candidates[item["index"]][1:])
+                       for item in reranked[group][:top_k]]
         exact = indexer.overlay_exact_keys(overlay, query)
         if exact:
             pinned = [(c[0], "overlay", c[1:]) for c in candidates if tuple(c[1:4]) in exact][:2]
@@ -1706,6 +1762,11 @@ def _handle_smart_scout(arguments):
         others = list(dict.fromkeys(f"{row['path']}:{row['lines']}" for row in rows
                                     if row["path"] not in shown))[:SCOUT_MAX_POINTERS]
         source = _SCOUT_SOURCES[found["source"]]
+        notes = []
+        if scout.is_intent_question(question):
+            dossier_answer = dossier.query(root, query, max_hits=scout.DECISION_NOTES_MAX)
+            notes = dossier_answer["hits"]
+            warnings += [f"decision notes: {reason}" for reason in dossier_answer["reasons"]]
         text = None
         if model and items:
             calls += 1
@@ -1716,7 +1777,8 @@ def _handle_smart_scout(arguments):
                 found_answer, answer, citations = scout.valid_answer(raw, items)
                 note = f"{model} ({calls} call{'s' if calls > 1 else ''})"
                 if citations:
-                    text = scout.render(question, source, items, citations, answer, found_answer, note, warnings, others)
+                    text = scout.render(question, source, items, citations, answer, found_answer, note, warnings, others,
+                                        notes)
                 else:
                     shown_items = scout.evidence(root, rows, terms, max_files,
                                                  scout.LEXICAL_WINDOW_LINES)[:scout.UNCITED_WINDOWS]
@@ -1724,14 +1786,14 @@ def _handle_smart_scout(arguments):
                             if item["path"] not in {kept["path"] for kept in shown_items}]
                     text = scout.render(question, source, shown_items, None, answer, found_answer, note,
                                         warnings + ["the scout_model cited no lines; the best keyword windows are shown "
-                                                    "instead."], rest + others)
+                                                    "instead."], rest + others, notes)
             except Exception as exc:
                 warnings.append(f"scout_model {model} failed writing the answer ({_project_error(exc)}): literal lines "
                                 "only, no answer.")
                 failure = "answer"
                 items = scout.evidence(root, rows, terms, max_files, scout.LEXICAL_WINDOW_LINES)
         if text is None:
-            text = scout.render(question, source, items, warnings=warnings, others=others)
+            text = scout.render(question, source, items, warnings=warnings, others=others, notes=notes)
     _metric("scout", source=found["source"], model=bool(model) and failure is None, model_calls=calls, failure=failure,
             files=len({item["path"] for item in items}), chars=len(text), elapsed_s=round(time.monotonic() - started, 2))
     return _sanitize_text(text)

package/tray.py

@@ -22,6 +22,7 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import autostart
 import config
 import daemon_launcher
+import setup_audit
 import toast_notice
 import update_check
 import version
@@ -114,7 +115,8 @@ def _poll_loop(icon):
 
 
 def _show_notices(icon, notices):
-    """Shows a toast for each pending notice: the new-default-models offer and each model over the failure limit."""
+    """Shows a toast for each pending notice: the new-default-models offer, each model over the failure limit and each
+    project whose scheduled setup audit found new errors or warnings."""
     offer = notices.get("upgrade")
     if offer:
         lines = [f"{role}: {change['current']} -> {change['new']}" for role, change in offer["changes"].items()]
@@ -129,6 +131,10 @@ def _show_notices(icon, notices):
             f"{row['model']} is failing", [f"{row['errors']} of {row['calls']} calls failed in 24 h as {row['role']}.", last[:160]],
             [("Switch model", toast_notice.action_uri("open-setup", section="models")),
              ("Mute 7 days", toast_notice.action_uri("mute-model", model=row["model"]))], tag="model-failing:" + row["model"])
+    for row in notices.get("audit") or []:
+        title, lines = setup_audit.toast_text(row)
+        toast_notice.show(title, lines, [("Open the audit", toast_notice.action_uri("open-setup", section="audit"))],
+                          tag="setup-audit:" + row["project"])
 
 
 def _notice_loop(icon):

package/usage_meter.py

@@ -97,6 +97,19 @@ def _record_job(job_id,payload):
         db.execute('DELETE FROM usage_index_jobs WHERE at<?',(time.time()-366*86400,))
 
 
+def calls_by_purpose(since,purposes):
+    """Attempts and errors of every project per purpose in `purposes`, from the UTC day of the epoch time `since` on
+    (the table keeps days, not hours). Purposes with no call are left out."""
+    day=datetime.datetime.fromtimestamp(since,datetime.timezone.utc).date().isoformat()
+    marks=','.join('?' for _ in purposes)
+    with project_store._LOCK,project_store._db() as db:
+        _tables(db)
+        rows=db.execute('SELECT purpose,SUM(attempts),SUM(errors) FROM usage_daily WHERE day>=? AND purpose IN ('+marks+') GROUP BY purpose',
+                        (day,*purposes)).fetchall()
+    found={purpose:{'purpose':purpose,'attempts':attempts,'errors':errors} for purpose,attempts,errors in rows}
+    return [found[purpose] for purpose in purposes if purpose in found]
+
+
 def summary(project_id,days=30,view_id=None):
     if type(days) is not int or not 1<=days<=366:raise ValueError('Choose a period from 1 to 366 days.')
     with project_store._LOCK,project_store._db() as db:

package/version.py

@@ -1,7 +1,7 @@
 """Single source of the Smart Tool version and of the User-Agent sent to public APIs."""
 import re
 
-VERSION = "0.9.39"
+VERSION = "0.9.41"
 _CONTACT_RE = re.compile(r"^(?:[^\s@()<>;]+@[^\s@()<>;]+\.[^\s@()<>;]+|https?://[^\s()<>;]+)$")
 
 

package/web_fetch.py

@@ -20,14 +20,13 @@ import ipaddress
 import json
 import socket
 import ssl
-import subprocess
-import sys
 import threading
 import time
 import urllib.parse
 
 import trafilatura
 
+import document_text
 import model_client
 import research_cache
 
@@ -39,8 +38,7 @@ SELECT_BUDGET_CHARS = 15_000
 CHUNK_CHARS = 2_000
 PAGE_FORMAT = 2
 MAX_DOWNLOAD_BYTES = 5 * 1024 * 1024
-PDF_MAX_PAGES = 300
-PDF_TIMEOUT_S = 30
+PDF_INTERACTIVE_TIMEOUT_S = 30  # Override of document_text.PDF_TIMEOUT_S: a person waits for this answer, the indexer does not.
 MAX_REDIRECTS = 5
 HTTP_TIMEOUT_S = 20
 READ_CHUNK = 64 * 1024
@@ -212,46 +210,20 @@ def thin(text):
     return len(stripped) < PLACEHOLDER_SCAN_CHARS and any(p in stripped[:600].lower() for p in PLACEHOLDERS)
 
 
-PDF_SCRIPT = """
-import io, json, sys
-import pypdf
-reader = pypdf.PdfReader(io.BytesIO(sys.stdin.buffer.read()))
-if reader.is_encrypted and reader.decrypt("") == pypdf.PasswordType.NOT_DECRYPTED:
-    print(json.dumps({"encrypted": True}))
-    sys.exit()
-limit, budget = int(sys.argv[1]), int(sys.argv[2])
-pages, size = [], 0
-for page in reader.pages[:limit]:
-    pages.append((page.extract_text() or "").strip()[:budget - size])
-    size += len(pages[-1])
-    if size >= budget:
-        break
-print(json.dumps({"pages": pages, "count": len(reader.pages)}))
-"""
-
-
 def pdf_text(body, url, deadline):
-    """Text of a PDF (pypdf, pure Python), page by page up to PDF_MAX_PAGES. The native WebFetch reads PDFs and the hook
-    sends it here, so a PDF used to be a dead end (9 times in 10 days of transcripts). A hostile PDF can make pypdf
-    parse for minutes, so it runs in a subprocess killed at the request's deadline (at most PDF_TIMEOUT_S)."""
-    timeout = min(PDF_TIMEOUT_S, _left(deadline))
+    """Text of a PDF (pypdf, pure Python), page by page, with the page and character caps of document_text. The native
+    WebFetch reads PDFs and the hook sends it here, so a PDF used to be a dead end (9 times in 10 days of transcripts).
+    A hostile PDF can make pypdf parse for minutes, so it runs in a subprocess killed at the request's deadline (at most
+    PDF_INTERACTIVE_TIMEOUT_S, passed to document_text.run_pdf instead of the indexer's document_text.PDF_TIMEOUT_S)."""
+    timeout = min(PDF_INTERACTIVE_TIMEOUT_S, _left(deadline))
     try:
-        done = subprocess.run([sys.executable, "-I", "-c", PDF_SCRIPT, str(PDF_MAX_PAGES), str(PAGE_STORE_MAX_CHARS)],
-                              input=body, capture_output=True, timeout=timeout,
-                              creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0))
-    except subprocess.TimeoutExpired:
+        return document_text.run_pdf(body, timeout, document_text.PDF_MAX_PAGES, document_text.PDF_MAX_CHARS)
+    except document_text.PdfTimeout:
         raise FetchError(f"PDF not read in {timeout:.0f}s ({url}).") from None
-    if done.returncode:
-        detail = (done.stderr.decode("utf-8", "replace").strip().splitlines() or ["no output"])[-1]
-        raise FetchError(f"PDF could not be read ({url}): {detail}"[:300])
-    result = json.loads(done.stdout)
-    if result.get("encrypted"):
-        raise FetchError(f"PDF protected by a password is not read by web_fetch ({url}).")
-    pages = result["pages"]
-    text = "\n\n".join(f"[page {number}]\n{page}" for number, page in enumerate(pages, 1) if page)
-    if result["count"] > len(pages):
-        text += f"\n\n[pages {len(pages) + 1}-{result['count']} not read]"
-    return text
+    except document_text.PdfUnreadable as exc:
+        raise FetchError(f"PDF could not be read ({url}): {exc.detail}"[:300]) from None
+    except document_text.PdfEncrypted:
+        raise FetchError(f"PDF protected by a password is not read by web_fetch ({url}).") from None
 
 
 def read_page(url, deadline, render):