wrapper.
_MAIN_CANDIDATES = (
"main",
"article",
@@ -80,9 +71,6 @@ def html_to_markdown(html: str, *, main_content: bool = True) -> str:
target = main
md = markdownify(str(target), heading_style="ATX")
- # Markdownify can leave long runs of blank lines from divs/spans;
- # collapse runs of >2 blank lines down to 2 so the markdown reads
- # cleanly without changing the structural meaning.
lines = md.splitlines()
out: list[str] = []
blanks = 0
diff --git a/pyagent/plugins/memory/__init__.py b/pyagent/plugins/memory/__init__.py
index 77c77ac..18a5e6c 100644
--- a/pyagent/plugins/memory/__init__.py
+++ b/pyagent/plugins/memory/__init__.py
@@ -44,26 +44,13 @@
_LEDGERS = {"USER": "USER.md", "MEMORY": "MEMORY.md"}
_MEMORIES_DIRNAME = "memories"
-# ---- Recall (vector) constants ----------------------------------
-#
-# Embedding model for `recall_memory`. fastembed downloads it on first
-# use (~130 MB once-only). bge-small-en-v1.5 is the current sweet
-# spot for English embedding speed × quality at agent-memory scale.
_MODEL_NAME = "BAAI/bge-small-en-v1.5"
-# Bullet shape recall_memory parses out of MEMORY.md to map filename
-# → (title, hook) at query time. Loose enough for `-`, `*`, `+`
-# bullets and the various dash/colon separators we've seen between
-# title and hook.
_INDEX_LINE_RE = re.compile(
r"\s*[-*+]\s*\[(?P[^\]]+)\]\((?P<file>[^)]+\.md)\)"
r"(?:\s*[—\-:]\s*(?P<hook>.+))?\s*$"
)
-# Process-local cache so multiple recalls in one session don't
-# re-instantiate the embedding model. fastembed itself caches model
-# weights on disk, but the Python-side ONNX session has nontrivial
-# init cost.
_model = None
@@ -96,34 +83,11 @@ def _get_model():
_model = TextEmbedding(model_name=_MODEL_NAME)
return _model
-# Memory filenames must be lowercase snake_case with a .md suffix.
-# Why this strict: filenames are embedded into recall_memory's
-# searchable text via _filename_search_terms (above), so a
-# consistent shape keeps recall predictable. Also stops the agent
-# from drifting into mixed-case or spaced filenames that look
-# inconsistent in the index.
+
_FILENAME_RE = re.compile(r"^[a-z0-9][a-z0-9_]*\.md$")
-# Two-stage drift check:
-#
-# (1) Token-level containment. Splitting on whitespace, if the
-# target's token set is a strict subset/superset of an existing
-# category's, that's the "Code Style" / "Style" case — flag it.
-# Pure character similarity misses this (ratio is only ~0.67),
-# and lowering the threshold to catch it produces false positives
-# on unrelated 1-char-different names ("Stack" vs "Slack").
-#
-# (2) Fuzzy similarity at 0.85 for the leftover cases — pluralization
-# ("Database" vs "Databases" ~0.94, "Style" vs "Styles" ~0.91)
-# and minor typos. 0.85 is high enough to ignore "Stack" vs
-# "Slack" (0.80) and "Stack" vs "Snack" (0.80).
_CATEGORY_FUZZY_THRESHOLD = 0.85
-# When the rendered MEMORY.md section has at least this many
-# categories, we prepend a compact "Categories in use: ..." summary
-# above the bulleted detail so the agent can scan available
-# headings without parsing the full structure. Below this count
-# the bullets are short enough that scanning them is cheap.
_CATEGORY_SUMMARY_MIN = 5
@@ -146,12 +110,14 @@ def _parse_index_entries_at(index_text: str) -> list[tuple[str, str, str, str]]:
m = _INDEX_LINE_RE.match(line)
if not m:
continue
- out.append((
- current_category,
- m.group("title").strip(),
- m.group("file").strip(),
- (m.group("hook") or "").strip(),
- ))
+ out.append(
+ (
+ current_category,
+ m.group("title").strip(),
+ m.group("file").strip(),
+ (m.group("hook") or "").strip(),
+ )
+ )
return out
@@ -177,9 +143,7 @@ def _extract_categories(index_text: str) -> list[str]:
return out
-def _find_similar_category(
- target: str, existing: list[str]
-) -> str | None:
+def _find_similar_category(target: str, existing: list[str]) -> str | None:
"""Return the closest existing category name if it's confusingly
close to ``target``, else None. Case-insensitive comparison.
@@ -202,19 +166,12 @@ def _find_similar_category(
if not target_lc:
return None
- # If ANY existing category matches case-insensitively, defer to
- # _insert_index_bullet's case-insensitive collapse. Without this
- # short-circuit, ``create_memory("STYLE")`` against an index that
- # already has both ``Style`` and ``Code Style`` would trip the
- # subset check on ``Code Style`` and refuse — but the canonical
- # destination is the existing literal-match ``Style``.
for cat in existing:
if cat.lower().strip() == target_lc:
return None
target_tokens = set(target_lc.split())
- # Stage 1: token containment (strict subset / superset).
for cat in existing:
cat_lc = cat.lower().strip()
if not cat_lc:
@@ -225,7 +182,6 @@ def _find_similar_category(
if target_tokens < cat_tokens or cat_tokens < target_tokens:
return cat
- # Stage 2: fuzzy similarity for the leftover near-equal cases.
best_ratio = 0.0
best_match: str | None = None
for cat in existing:
@@ -267,9 +223,7 @@ def _validate_memory_filename(file: str) -> str | None:
return None
-def _insert_index_bullet(
- index_text: str, category: str, bullet: str
-) -> str:
+def _insert_index_bullet(index_text: str, category: str, bullet: str) -> str:
"""Insert `bullet` under `## <category>` in `index_text`.
Match category case-insensitively against existing H2 headings.
@@ -277,10 +231,7 @@ def _insert_index_bullet(
at the end of the file. Strips the `(no memories yet)` seed
placeholder if present. Returns the new full text.
"""
- lines = [
- ln for ln in index_text.splitlines()
- if ln.strip() != "(no memories yet)"
- ]
+ lines = [ln for ln in index_text.splitlines() if ln.strip() != "(no memories yet)"]
target_idx = None
for i, line in enumerate(lines):
@@ -292,22 +243,15 @@ def _insert_index_bullet(
break
if target_idx is not None:
- # Find end of this section: next H2, or EOF.
insert_at = len(lines)
for j in range(target_idx + 1, len(lines)):
if lines[j].lstrip().startswith("## "):
insert_at = j
break
- # Step back past trailing blanks so bullets cluster directly
- # under the heading.
- while (
- insert_at > target_idx + 1
- and lines[insert_at - 1].strip() == ""
- ):
+ while insert_at > target_idx + 1 and lines[insert_at - 1].strip() == "":
insert_at -= 1
lines.insert(insert_at, bullet)
else:
- # New category goes at the end.
while lines and lines[-1].strip() == "":
lines.pop()
if lines:
@@ -321,10 +265,6 @@ def _insert_index_bullet(
return text
-# Minimal YAML-flavored frontmatter parser. We only emit ``created_at:
-# <iso>`` blocks today; the parser is intentionally narrow — split on
-# the first ``:``, no quoting, no nesting, no lists. If the day comes
-# we need richer metadata, swap in a real YAML lib here.
_FRONTMATTER_RE = re.compile(r"\A---\n(?P<inner>.*?)\n---\n?", re.DOTALL)
@@ -344,7 +284,7 @@ def _split_frontmatter(text: str) -> tuple[dict[str, str], str]:
continue
k, v = line.split(":", 1)
meta[k.strip()] = v.strip()
- return meta, text[m.end():]
+ return meta, text[m.end() :]
def _format_frontmatter(meta: dict[str, str]) -> str:
@@ -360,9 +300,7 @@ def _format_frontmatter(meta: dict[str, str]) -> str:
def _now_iso() -> str:
"""Current UTC time as RFC 3339 / ISO 8601, second-precision."""
- return datetime.datetime.now(datetime.timezone.utc).isoformat(
- timespec="seconds"
- )
+ return datetime.datetime.now(datetime.UTC).isoformat(timespec="seconds")
def _atomic_write(path: Path, content: str) -> None:
@@ -430,8 +368,6 @@ def register(api):
plugin_dir = Path(__file__).parent
seeds = plugin_dir / "defaults"
- # Persistent ledger storage: <data-dir>/plugins/memory/.
- # Lazy-created on first access.
storage = api.user_data_dir
def _ledger_path(name: str) -> Path:
@@ -449,8 +385,6 @@ def _seed_if_missing(name: str) -> None:
target.parent.mkdir(parents=True, exist_ok=True)
shutil.copy(bundled, target)
- # ---- Tools ------------------------------------------------------
-
def read_memory(file: str) -> str:
"""Fetch a memory body from `memories/<file>`.
@@ -545,8 +479,6 @@ def update_memory(
"<update_memory needs at least one of `content`, "
"`description`, or `category` to be set>"
)
- # Reject empty content — degenerate state. Use delete_memory
- # to actually remove the body.
if content is not None and not content.strip():
return (
"<update_memory content is empty; use delete_memory "
@@ -564,18 +496,12 @@ def update_memory(
return err
body_path = _memory_file_path(filename)
- # Seed MEMORY.md if a user wiped it manually — the missing
- # bullet error below is more useful than "MEMORY.md not found".
_seed_if_missing("MEMORY")
index_path = _ledger_path("MEMORY")
if not index_path.exists():
return "<MEMORY.md not found>"
index_text = index_path.read_text()
- # Locate the bullet via the parsed index so we can match by
- # filename anchored to bullet shape (not raw substring).
- # Prevents clobbering another bullet whose description happens
- # to reference this memory by relative-link.
entries = _parse_index_entries_at(index_text)
bullet_entry: tuple[str, str, str, str] | None = next(
(e for e in entries if e[2] == filename), None
@@ -597,18 +523,11 @@ def update_memory(
actions: list[str] = []
- # Body update first, since a failed index write afterwards
- # can be retried via update_memory; a failed body write
- # before any index touch leaves the index untouched.
if content is not None:
if not body_path.exists():
return f"<body memories/{filename} not found>"
old_meta, _ = _split_frontmatter(body_path.read_text())
new_meta, new_body = _split_frontmatter(content)
- # Per-key merge: caller's keys win, absent keys preserved.
- # Without this, caller content with frontmatter that
- # lacks created_at would silently drop the existing
- # created_at — losing the memory's age.
merged_meta = {**old_meta, **new_meta}
if not new_body.endswith("\n"):
new_body = new_body + "\n"
@@ -620,16 +539,9 @@ def update_memory(
_atomic_write(body_path, final)
actions.append("body")
- # Index update: rewrite the bullet's description (in place)
- # then relocate (between sections) if both fields set. Order
- # matters because relocation moves the bullet line as a
- # whole — including any description we just spliced into it.
if description is not None or category is not None:
new_index = index_text
if description is not None:
- # Anchor the rewrite to bullet shape so a description
- # on another bullet that references this memory by
- # link doesn't get clobbered. Break after first hit.
needle = f"]({filename})"
rewritten: list[str] = []
done = False
@@ -654,8 +566,6 @@ def update_memory(
actions.append("description")
if category is not None:
- # Anchor to bullet shape; break on first hit. Same
- # rationale as the description rewrite above.
bullet_line: str | None = None
kept: list[str] = []
for line in new_index.splitlines():
@@ -668,9 +578,7 @@ def update_memory(
if bullet_line is None:
return f"<no bullet for {filename!r} in MEMORY.md>"
rebuilt = "\n".join(kept)
- new_index = _insert_index_bullet(
- rebuilt, category.strip(), bullet_line
- )
+ new_index = _insert_index_bullet(rebuilt, category.strip(), bullet_line)
actions.append(f"category → '{category.strip()}'")
_atomic_write(index_path, new_index)
@@ -751,14 +659,8 @@ def create_memory(
body_path = _memory_file_path(filename)
_seed_if_missing("MEMORY")
index_path = _ledger_path("MEMORY")
- index_text = (
- index_path.read_text() if index_path.exists() else ""
- )
+ index_text = index_path.read_text() if index_path.exists() else ""
- # Validation order: filename → collision → drift. Collision
- # is decisive (can't recover); drift is a soft warning the
- # caller can override. Doing collision first saves a wasted
- # retry where the caller fixed drift only to hit a clash.
if f"]({filename})" in index_text:
return (
f"<filename collision: memories/{filename} is "
@@ -778,16 +680,9 @@ def create_memory(
f"deliberately new heading>"
)
- # Body: prepend frontmatter and ensure trailing newline.
- # `created_at` lets read_memory and recall surface age.
body_text = content if content.endswith("\n") else content + "\n"
- body_with_meta = (
- _format_frontmatter({"created_at": _now_iso()}) + body_text
- )
+ body_with_meta = _format_frontmatter({"created_at": _now_iso()}) + body_text
- # O_EXCL on the body file: the OS does the existence check
- # atomically, eliminating the race between the index's "is
- # this filename in use?" check and the actual write.
body_path.parent.mkdir(parents=True, exist_ok=True)
try:
with open(body_path, "x", encoding="utf-8") as f:
@@ -798,23 +693,10 @@ def create_memory(
"between check and write; pick a different filename>"
)
- # Index update is atomic via temp-then-rename so a crash
- # leaves either the prior index or the new — never a
- # truncated one. If the rename fails (disk full, perms, etc.)
- # the body is already on disk; clean it up so a retry
- # doesn't collide on its own orphan via O_EXCL while the
- # index check still passes.
- bullet = (
- f"- [{title.strip()}]({filename})"
- + (
- f" — {description.strip()}"
- if description and description.strip()
- else ""
- )
- )
- new_index = _insert_index_bullet(
- index_text, category.strip(), bullet
+ bullet = f"- [{title.strip()}]({filename})" + (
+ f" — {description.strip()}" if description and description.strip() else ""
)
+ new_index = _insert_index_bullet(index_text, category.strip(), bullet)
index_path.parent.mkdir(parents=True, exist_ok=True)
try:
_atomic_write(index_path, new_index)
@@ -829,16 +711,6 @@ def create_memory(
)
return f"created {filename}: category='{category.strip()}'"
- # ---- Recall (vector) -------------------------------------------
- #
- # Fastembed is a hard dep in pyproject.toml. If it's missing the
- # install is broken — log a clear note and skip just the recall
- # tool rather than failing the whole plugin so add/read/write
- # still work. The plugin's [provides] manifest still declares
- # recall_memory, which means a missing-fastembed install fails
- # `_validate_provides` and the loader rejects the plugin entirely.
- # That's intentional: recall is part of the memory contract and
- # half-loading it silently is worse than refusing.
try:
import fastembed # noqa: F401
import numpy as np
@@ -877,49 +749,32 @@ def _gather_chunks() -> list[dict]:
chunks: list[dict] = []
for _category, title, filename, hook in _parse_index_entries():
fn_terms = _filename_search_terms(filename)
- text = (
- f"{fn_terms} {title}: {hook}"
- if hook
- else f"{fn_terms} {title}"
- )
+ text = f"{fn_terms} {title}: {hook}" if hook else f"{fn_terms} {title}"
chunks.append({"kind": "hook", "filename": filename, "text": text})
memories_dir = storage / _MEMORIES_DIRNAME
if memories_dir.exists():
for body_path in sorted(memories_dir.glob("*.md")):
fn_terms = _filename_search_terms(body_path.name)
_meta, body = _split_frontmatter(body_path.read_text())
- # Filename tokens prepended on their own line so the
- # body text is preserved as-is for the embedder; the
- # double newline keeps them as a "topic anchor"
- # rather than fusing with the body's first sentence.
- chunks.append({
- "kind": "body",
- "filename": body_path.name,
- "text": f"{fn_terms}\n\n{body}",
- })
+ chunks.append(
+ {
+ "kind": "body",
+ "filename": body_path.name,
+ "text": f"{fn_terms}\n\n{body}",
+ }
+ )
return chunks
def _is_index_stale() -> bool:
vec_path, idx_path = _vec_index_paths()
if not vec_path.exists() or not idx_path.exists():
return True
- idx_mtime = min(
- vec_path.stat().st_mtime, idx_path.stat().st_mtime
- )
+ idx_mtime = min(vec_path.stat().st_mtime, idx_path.stat().st_mtime)
index_path = _ledger_path("MEMORY")
- if (
- index_path.exists()
- and index_path.stat().st_mtime > idx_mtime
- ):
+ if index_path.exists() and index_path.stat().st_mtime > idx_mtime:
return True
memories_dir = storage / _MEMORIES_DIRNAME
if memories_dir.exists():
- # Stat the directory itself: its mtime updates when any
- # entry is added or removed. Catches deletes (a deleted
- # body file no longer appears in glob, so the per-file
- # loop below wouldn't notice it). Without this check, a
- # delete_memory orphan-body unlink could leave stale
- # rows in the vec index pointing at a nonexistent body.
if memories_dir.stat().st_mtime > idx_mtime:
return True
for f in memories_dir.glob("*.md"):
@@ -932,8 +787,6 @@ def _build_and_save():
vec_path, idx_path = _vec_index_paths()
vec_path.parent.mkdir(parents=True, exist_ok=True)
if not chunks:
- # Wipe stale on-disk artifacts so an empty store doesn't
- # serve old hits.
for p in (vec_path, idx_path):
if p.exists():
p.unlink()
@@ -944,9 +797,6 @@ def _build_and_save():
norms = np.linalg.norm(vectors, axis=1, keepdims=True)
vectors = vectors / np.maximum(norms, 1e-9)
np.save(vec_path, vectors)
- # Strip the embedded text before saving — we re-derive
- # snippets from source files at query time, no need to
- # store twice.
meta = [{"kind": c["kind"], "filename": c["filename"]} for c in chunks]
idx_path.write_text(json.dumps(meta))
return vectors, meta
@@ -961,8 +811,7 @@ def _load_or_build():
return vectors, meta
except Exception as exc:
logger.warning(
- "memory: failed to load saved vector index (%s); "
- "rebuilding",
+ "memory: failed to load saved vector index (%s); " "rebuilding",
exc,
)
return _build_and_save()
@@ -1025,16 +874,12 @@ def recall_memory(
if vectors is None or len(meta) == 0:
return "<no memories indexed yet>"
model = _get_model()
- q_vec = np.asarray(
- next(iter(model.embed([query]))), dtype=np.float32
- )
+ q_vec = np.asarray(next(iter(model.embed([query]))), dtype=np.float32)
q_vec = q_vec / max(float(np.linalg.norm(q_vec)), 1e-9)
scores = vectors @ q_vec # cosine since normalized
entries = _parse_index_entries()
file_to_cat = {f: c for c, _t, f, _h in entries}
hook_lookup = {f: h for _c, _t, f, h in entries if h}
- # Group by filename: keep highest-scoring chunk per file so a
- # body and its hook don't both show up.
best: dict[str, tuple[float, dict]] = {}
for i, m in enumerate(meta):
score = float(scores[i])
@@ -1045,9 +890,9 @@ def recall_memory(
target_cat = category.strip().lower() if category else None
cutoff: datetime.datetime | None = None
if created_within_days is not None:
- cutoff = datetime.datetime.now(
- datetime.timezone.utc
- ) - datetime.timedelta(days=created_within_days)
+ cutoff = datetime.datetime.now(datetime.UTC) - datetime.timedelta(
+ days=created_within_days
+ )
filtered: list[tuple[str, tuple[float, dict]]] = []
for filename, (score, m) in best.items():
@@ -1058,10 +903,6 @@ def recall_memory(
if actual.lower() != target_cat:
continue
if cutoff is not None:
- # Read the body's frontmatter to find created_at.
- # Drop on missing-frontmatter when the filter is set:
- # the ask is "recent stuff", and undated entries
- # can't qualify. Cheap because k is small.
body_path = storage / _MEMORIES_DIRNAME / filename
if not body_path.exists():
continue
@@ -1078,8 +919,6 @@ def recall_memory(
filtered.append((filename, (score, m)))
ranked = sorted(filtered, key=lambda kv: -kv[1][0])[:k]
- # Header reflects active filters so the agent knows what
- # was applied; unfiltered output is unchanged.
filter_parts = []
if min_score > 0:
filter_parts.append(f"min_score={min_score:.2f}")
@@ -1087,9 +926,7 @@ def recall_memory(
filter_parts.append(f"category={category!r}")
if created_within_days is not None:
filter_parts.append(f"created_within_days={created_within_days}")
- filter_suffix = (
- f" ({', '.join(filter_parts)})" if filter_parts else ""
- )
+ filter_suffix = f" ({', '.join(filter_parts)})" if filter_parts else ""
if not ranked:
if filter_parts:
@@ -1100,9 +937,7 @@ def recall_memory(
)
return f"<no matches for {query!r}>"
- lines = [
- f"Top {len(ranked)} matches for {query!r}{filter_suffix}:"
- ]
+ lines = [f"Top {len(ranked)} matches for {query!r}{filter_suffix}:"]
for filename, (score, m) in ranked:
cat = file_to_cat.get(filename, "")
cat_str = f", category='{cat}'" if cat else ""
@@ -1140,7 +975,6 @@ def delete_memory(filename: str) -> str:
index_path = _ledger_path("MEMORY")
body_path = _memory_file_path(filename)
- # Strip the bullet line (if present) from MEMORY.md.
bullet_removed = False
if index_path.exists():
text = index_path.read_text()
@@ -1182,13 +1016,6 @@ def delete_memory(filename: str) -> str:
api.register_tool("write_user", write_user)
api.register_tool("recall_memory", recall_memory)
- # ---- Prompt sections --------------------------------------------
- #
- # Three sections, all volatile=False (stable across turns; cache
- # stays warm). USER and MEMORY-INDEX content changes when the
- # agent writes to them — that breaks the cache for one turn,
- # then re-warms.
-
prompt_path = seeds / "PROMPT.md"
def render_memory_guidance(ctx) -> str:
@@ -1228,12 +1055,7 @@ def render_memory_index(ctx) -> str:
text = target.read_text()
cats = _extract_categories(text)
if len(cats) >= _CATEGORY_SUMMARY_MIN:
- summary = (
- f"\n*Categories in use: {', '.join(sorted(cats))}.*\n"
- )
- # Insert immediately after the H1 heading line so the
- # summary sits at the top of the section, above the
- # template preamble and the bulleted detail.
+ summary = f"\n*Categories in use: {', '.join(sorted(cats))}.*\n"
head, sep, tail = text.partition("\n")
if head.startswith("# ") and sep:
text = f"{head}{sep}{summary}{tail}"
@@ -1244,27 +1066,13 @@ def render_memory_index(ctx) -> str:
api.register_prompt_section(
"memory-guidance", render_memory_guidance, volatile=False
)
- api.register_prompt_section(
- "user-ledger", render_user_ledger, volatile=False
- )
- api.register_prompt_section(
- "memory-index", render_memory_index, volatile=False
- )
-
- # ---- Lifecycle hooks --------------------------------------------
+ api.register_prompt_section("user-ledger", render_user_ledger, volatile=False)
+ api.register_prompt_section("memory-index", render_memory_index, volatile=False)
def on_start(session):
- # Seed both ledgers so the first read returns the template
- # rather than an empty string. Idempotent.
for name in _LEDGERS:
_seed_if_missing(name)
- # One-time orphan notice. Users coming from the pre-plugin
- # era have memory at <config-dir>/MEMORY.md and
- # <config-dir>/USER.md. The plugin's storage is at
- # <data-dir>/plugins/memory/, so legacy files now sit on
- # disk unused. We don't touch user data — just point them
- # out once so the user knows they can delete by hand.
sentinel = storage / ".legacy-notice-shown"
if not sentinel.exists():
legacy = []
diff --git a/pyagent/plugins/ollama/__init__.py b/pyagent/plugins/ollama/__init__.py
index 13f9ee5..01b637c 100644
--- a/pyagent/plugins/ollama/__init__.py
+++ b/pyagent/plugins/ollama/__init__.py
@@ -29,16 +29,10 @@
logger = logging.getLogger(__name__)
-# Capabilities we filter from the per-model tag list before showing
-# them to the user. ``completion`` is reported by every chat model so
-# it carries no information; ``insert`` is fill-in-the-middle
-# infrastructure that pyagent doesn't surface as a feature.
_BORING_CAPABILITIES = {"completion", "insert"}
def _factory(**kw: Any):
- # Lazy import: keeps `requests` and the client class out of the
- # plugin-load critical path for users who never invoke ollama.
from pyagent.plugins.ollama.client import OllamaClient
model = kw.get("model") or ""
@@ -99,17 +93,12 @@ def _list_models():
def register(api):
- # Snapshot the env at register time so `default_model` on the
- # ProviderSpec is stable for the agent process. Reading later
- # would mean different subagents (or the same agent after a hot
- # config change) could see different defaults — surprising.
default_model = os.environ.get("OLLAMA_MODEL", "")
api.register_provider(
"ollama",
_factory,
default_model=default_model,
- env_vars=(), # local server, no required env
+ env_vars=(),
list_models=_list_models,
)
-
diff --git a/pyagent/plugins/ollama/client.py b/pyagent/plugins/ollama/client.py
index e193d20..adae17f 100644
--- a/pyagent/plugins/ollama/client.py
+++ b/pyagent/plugins/ollama/client.py
@@ -33,7 +33,8 @@
import json
import logging
import os
-from typing import Any, Callable
+from typing import Any
+from collections.abc import Callable
import requests
@@ -44,26 +45,10 @@
DEFAULT_HOST = "http://localhost:11434"
-# Long timeout because the first request after a cold start can sit
-# waiting for Ollama to mmap/load a multi-GB GGUF before any tokens
-# come back.
DEFAULT_TIMEOUT = 600
-# Ollama's server defaults to num_ctx=2048/4096 regardless of what the
-# model architecture supports, silently truncating tool-heavy pyagent
-# prompts. We override that. Floor (when the architecture window is
-# unknown) is 2x the server default so basic prompts fit; cap (when
-# the architecture window is huge, e.g. llama3.2's 128k) bounds KV-
-# cache memory on small local boxes — at fp16 a 3B-class model burns
-# ~110 KB/token, so 16k ≈ ~2 GB just for KV. Override with
-# PYAGENT_OLLAMA_NUM_CTX to bypass both.
+# Ollama server defaults num_ctx to 2048/4096 regardless of model arch; override.
NUM_CTX_FLOOR = 8192
NUM_CTX_CAP = 16384
-# Hardcoded fallback when nothing in env or config supplies a
-# temperature. Kept low because Ollama's 0.8 server default lets
-# multilingual models (qwen 2.5 14b) drift out of English mid-reply
-# and weaker tool-callers (llama 3.1 8b) hallucinate fake JSON tool
-# calls into the message body. Override globally in `[ollama]
-# temperature` or per model in `[ollama.temperature_per_model]`.
DEFAULT_TEMPERATURE = 0.3
@@ -90,8 +75,6 @@ def _raise_with_body(resp: requests.Response, where: str) -> None:
else:
detail = str(body)
except (ValueError, requests.exceptions.JSONDecodeError):
- # Non-JSON body — fall back to the raw text, capped so a stray
- # HTML error page doesn't blow up the log.
detail = (resp.text or "").strip()[:500]
msg = f"Ollama {where} returned {resp.status_code}"
if detail:
@@ -161,28 +144,12 @@ def __init__(
timeout: float = DEFAULT_TIMEOUT,
) -> None:
if not model:
- raise ValueError(
- "OllamaClient requires a model name; got empty string"
- )
+ raise ValueError("OllamaClient requires a model name; got empty string")
self.model = model
self.provider_model = f"ollama/{model}"
self.host = (host or _resolve_host()).rstrip("/")
self.timeout = timeout
- # Latched once we discover (via a 400 retry) that this model
- # rejects the `tools` field. Subsequent turns skip tools so we
- # don't burn a wasted round trip per call. We avoid a
- # `/api/show` preflight on construction so the lazy-network
- # contract holds — the cost is exactly one extra failed
- # request the first time a no-tools model is used.
self._skip_tools = False
- # /api/show is consulted by both the context-window lookup
- # and the dialect detection. We cache the whole payload so
- # both can read from it without paying for two round trips
- # on the first turn. None = not yet fetched; {} = fetched-
- # and-failed (server unreachable, /api/show errored). Both
- # downstream consumers latch their own derived values, so
- # transient failures stick — same behavior the prior
- # context-window cache had.
self._show_payload: dict[str, Any] | None = None
self._context_window: int | None = None
self._dialect: dialects.Dialect | None = None
@@ -218,10 +185,6 @@ def context_window(self) -> int:
"""
if self._context_window is not None:
return self._context_window
- # Ollama's /api/show puts the architecture's context length
- # under model_info["<family>.context_length"]. The family
- # name varies (llama, qwen2, mistral, ...), so scan all keys
- # ending with `.context_length` and take the first hit.
model_info = self._show().get("model_info") or {}
if isinstance(model_info, dict):
for key, val in model_info.items():
@@ -290,9 +253,11 @@ def _resolve_temperature(self) -> float:
per_model = cfg.get("temperature_per_model") or {}
if isinstance(per_model, dict) and self.model in per_model:
candidate = per_model[self.model]
- if isinstance(candidate, (int, float)) and not isinstance(
- candidate, bool
- ) and candidate >= 0:
+ if (
+ isinstance(candidate, (int, float))
+ and not isinstance(candidate, bool)
+ and candidate >= 0
+ ):
return float(candidate)
logger.warning(
"[ollama.temperature_per_model] %r = %r is not a "
@@ -302,14 +267,15 @@ def _resolve_temperature(self) -> float:
)
candidate = cfg.get("temperature")
- if isinstance(candidate, (int, float)) and not isinstance(
- candidate, bool
- ) and candidate >= 0:
+ if (
+ isinstance(candidate, (int, float))
+ and not isinstance(candidate, bool)
+ and candidate >= 0
+ ):
return float(candidate)
if candidate is not None:
logger.warning(
- "[ollama] temperature = %r is not a non-negative "
- "number; ignoring",
+ "[ollama] temperature = %r is not a non-negative " "number; ignoring",
candidate,
)
@@ -366,9 +332,6 @@ def respond(
on_text_delta: Callable[[str], None] | None = None,
) -> dict[str, Any]:
messages: list[dict[str, Any]] = []
- # Ollama has no prefix-cache surface to preserve, so stable +
- # volatile concatenate into one system message — same shape
- # the OpenAI client uses.
full_system = system or ""
if system_volatile:
full_system = (
@@ -381,11 +344,6 @@ def respond(
for m in conversation:
messages.extend(self._to_ollama(m))
- # Streaming hinges entirely on the on_text_delta callback. When
- # set, ask Ollama to NDJSON-stream and surface chunks as they
- # arrive; when unset, ask for a single-shot reply so callers
- # like the audit / bench paths that just want the final dict
- # don't pay any iteration overhead.
streaming = on_text_delta is not None
body: dict[str, Any] = {
"model": self.model,
@@ -438,10 +396,7 @@ def _post_chat(self, body: dict[str, Any]) -> requests.Response:
try:
_raise_with_body(resp, "/api/chat")
except requests.HTTPError as e:
- if (
- "does not support tools" in str(e).lower()
- and "tools" in body
- ):
+ if "does not support tools" in str(e).lower() and "tools" in body:
logger.warning(
"ollama model %r does not support tools; retrying "
"without (subsequent turns in this session will skip "
@@ -483,9 +438,6 @@ def _build_response(self, data: dict[str, Any]) -> dict[str, Any]:
fn = tc.get("function") or {}
args = fn.get("arguments")
if isinstance(args, str):
- # Some Ollama versions/models hand back JSON-stringified
- # arguments; normalise to dict so the agent sees a
- # uniform shape regardless of model quirks.
try:
args = json.loads(args)
except json.JSONDecodeError:
@@ -542,9 +494,6 @@ def _consume_stream(
try:
chunk = json.loads(raw)
except json.JSONDecodeError:
- # Malformed line — skip rather than blow up the
- # whole turn. Real Ollama servers don't emit
- # these but a flaky proxy might.
logger.debug("ollama: skipping malformed NDJSON line: %r", raw)
continue
@@ -565,10 +514,6 @@ def _consume_stream(
except Exception:
pass
- # Reconstruct a single-shot-shaped payload so _build_response
- # can do the rest. The accumulated text wins over whatever
- # `message.content` ended up on the final chunk (which is
- # typically empty in streaming mode anyway).
synthetic = dict(final_meta)
synthetic["message"] = {
"role": "assistant",
@@ -580,9 +525,6 @@ def _consume_stream(
def _to_ollama(self, message: dict[str, Any]) -> list[dict[str, Any]]:
if message["role"] == "user":
if "tool_results" in message:
- # Ollama's tool-result wire shape is just role="tool"
- # with content; tool_name is a hint that newer models
- # honor and older ones ignore safely.
return [
{
"role": "tool",
@@ -593,26 +535,13 @@ def _to_ollama(self, message: dict[str, Any]) -> list[dict[str, Any]]:
]
return [{"role": "user", "content": message["content"]}]
- # assistant — content is required even when only tool_calls
- # are present, so default to "" rather than omitting.
text = message.get("content") or ""
tool_calls = message.get("tool_calls") or []
if tool_calls and text:
- # Mixed turn (prose + tool_call). Most chat templates
- # render assistant ``.Content`` OR ``.ToolCalls`` but
- # never both — qwen-style drops the calls when content
- # is set, llama-style does the inverse. Either way the
- # next turn loses information and the model gets confused.
- # Inline the calls into content using the family's native
- # envelope, then omit the structured tool_calls field so
- # the template's content branch renders our hand-built
- # block unchanged. See pyagent.plugins.ollama.dialects
- # for the per-family envelope and detection rules.
+ # Mixed prose+tool_call turn: inline calls via family envelope and drop structured tool_calls so templates don't silently drop one channel.
inlined = self.dialect.render_tool_calls_in_content(tool_calls)
- return [
- {"role": "assistant", "content": f"{text}\n{inlined}"}
- ]
+ return [{"role": "assistant", "content": f"{text}\n{inlined}"}]
msg: dict[str, Any] = {"role": "assistant", "content": text}
if tool_calls:
diff --git a/pyagent/plugins/ollama/dialects.py b/pyagent/plugins/ollama/dialects.py
index c61e8e1..6865078 100644
--- a/pyagent/plugins/ollama/dialects.py
+++ b/pyagent/plugins/ollama/dialects.py
@@ -46,9 +46,7 @@ class Dialect:
name: str = "default"
- def render_tool_calls_in_content(
- self, tool_calls: list[dict[str, Any]]
- ) -> str:
+ def render_tool_calls_in_content(self, tool_calls: list[dict[str, Any]]) -> str:
"""Return the in-content envelope for the given tool calls.
Caller is responsible for composing this with any preceding
@@ -68,9 +66,7 @@ class QwenDialect(Dialect):
name = "qwen"
- def render_tool_calls_in_content(
- self, tool_calls: list[dict[str, Any]]
- ) -> str:
+ def render_tool_calls_in_content(self, tool_calls: list[dict[str, Any]]) -> str:
body = "\n".join(
json.dumps({"name": tc["name"], "arguments": tc["args"]})
for tc in tool_calls
@@ -90,9 +86,7 @@ class LlamaDialect(Dialect):
name = "llama"
- def render_tool_calls_in_content(
- self, tool_calls: list[dict[str, Any]]
- ) -> str:
+ def render_tool_calls_in_content(self, tool_calls: list[dict[str, Any]]) -> str:
return "\n".join(
json.dumps({"name": tc["name"], "parameters": tc["args"]})
for tc in tool_calls
diff --git a/pyagent/plugins/py_dev_toolkit/__init__.py b/pyagent/plugins/py_dev_toolkit/__init__.py
index 8f989b8..15fbfc1 100644
--- a/pyagent/plugins/py_dev_toolkit/__init__.py
+++ b/pyagent/plugins/py_dev_toolkit/__init__.py
@@ -36,7 +36,6 @@
from pyagent.plugins.py_dev_toolkit import pytest_runner as _pytest_runner
from pyagent.plugins.py_dev_toolkit import typecheck as _typecheck
-
_PYTHON_GUIDANCE = """\
## Python environments
@@ -62,23 +61,10 @@ def _render_python_guidance(_ctx) -> str:
def register(api):
- # Role-only: Python dev tools belong in PYTHON_ENGINEER's
- # allowlist, not on the root agent (which rarely needs to lint
- # or run pytest in routine work). Working agents that need
- # Python verification spawn the python-engineer role.
api.register_tool("lint", _lint.run, role_only=True)
api.register_tool("typecheck", _typecheck.run, role_only=True)
api.register_tool("run_pytest", _pytest_runner.run, role_only=True)
- # python_env is the exception in this plugin: every agent role
- # benefits from being able to discover (and lazily bootstrap) the
- # workspace venv, so it's registered globally rather than gated.
- api.register_tool(
- "python_env", _python_env.make_python_env(api.workspace)
- )
- # Plugin-scoped guidance: only loaded when this plugin is, so
- # PRIMER stays language-agnostic. Static text — no per-turn
- # state, so volatile=False keeps it inside the cached system
- # block.
+ api.register_tool("python_env", _python_env.make_python_env(api.workspace))
api.register_prompt_section(
"python-guidance", _render_python_guidance, volatile=False
)
diff --git a/pyagent/plugins/py_dev_toolkit/_pathutil.py b/pyagent/plugins/py_dev_toolkit/_pathutil.py
index 9566de7..3e53b6e 100644
--- a/pyagent/plugins/py_dev_toolkit/_pathutil.py
+++ b/pyagent/plugins/py_dev_toolkit/_pathutil.py
@@ -29,7 +29,6 @@ def shorten(p: str) -> str:
cwd = Path.cwd().resolve()
return str(resolved.relative_to(cwd))
except (ValueError, OSError):
- # ValueError: not under cwd. OSError: filesystem hiccup.
try:
return str(Path(p).resolve())
except OSError:
diff --git a/pyagent/plugins/py_dev_toolkit/lint.py b/pyagent/plugins/py_dev_toolkit/lint.py
index e3a6b66..c3deb30 100644
--- a/pyagent/plugins/py_dev_toolkit/lint.py
+++ b/pyagent/plugins/py_dev_toolkit/lint.py
@@ -75,9 +75,6 @@ def run(path: str, tools: list[str] | None = None) -> str:
except subprocess.TimeoutExpired:
return f"<error: ruff timed out after {_TIMEOUT_S}s>"
- # ruff exits non-zero when findings exist; treat that as success
- # for our purposes. JSON parse failure is the actual error
- # condition (binary crashed, output corrupted).
out = proc.stdout or ""
try:
findings = json.loads(out) if out.strip() else []
@@ -108,13 +105,10 @@ def _format_findings(findings: list[dict], target: str) -> str:
fixable += 1
fix_marker = " — fixable"
file_rel = _shorten(f.get("filename", "?"))
- lines.append(
- f"- {file_rel}:{line}:{col} [{code}] {message}{fix_marker}"
- )
+ lines.append(f"- {file_rel}:{line}:{col} [{code}] {message}{fix_marker}")
sev_part = ", ".join(
- f"{n} {sev}{'s' if n != 1 else ''}"
- for sev, n in sorted(by_sev.items())
+ f"{n} {sev}{'s' if n != 1 else ''}" for sev, n in sorted(by_sev.items())
)
fix_part = f", {fixable} fixable" if fixable else ""
summary = (
diff --git a/pyagent/plugins/py_dev_toolkit/pytest_runner.py b/pyagent/plugins/py_dev_toolkit/pytest_runner.py
index ef5dc71..fbd8336 100644
--- a/pyagent/plugins/py_dev_toolkit/pytest_runner.py
+++ b/pyagent/plugins/py_dev_toolkit/pytest_runner.py
@@ -19,13 +19,8 @@
from pyagent import permissions
-# pytest can take a while; longer timeout than lint/typecheck. The
-# cap is a circuit breaker for hung tests, not a per-test budget.
_TIMEOUT_S = 600
-# How many failure / error tracebacks to embed in the summary. More
-# than this is hard to read at the agent level — the caller should
-# narrow with `k=` or look at attachments instead.
_MAX_FAILURES_SHOWN = 10
@@ -65,27 +60,10 @@ def run(
"`<pip> install pytest pytest-json-report` and retry>"
)
- # Always gate the target with `require_access`, even if it
- # doesn't exist on disk yet. A non-existent out-of-workspace
- # path (typo, wrong relative path, or deliberately escapist
- # `target="../../../etc/test_x.py"`) still causes pytest to be
- # invoked, and pytest's collection phase walks parent
- # directories for `conftest.py` / `pyproject.toml` — so the
- # right time to prompt is *before* invocation, regardless of
- # whether the named file exists.
- #
- # `require_access` is a no-op for paths that resolve inside the
- # workspace, so the common case (relative paths, default ".")
- # is silent.
target_path = Path(target.split("::", 1)[0])
if not permissions.require_access(target_path):
return f"<error: access denied to {target}>"
- # `mkstemp` over `NamedTemporaryFile(delete=False)`: on Windows
- # the latter can keep handles open across context-manager exit
- # and races the subprocess that wants to write to the same path.
- # `mkstemp` returns an fd we close immediately, leaving only the
- # path for the subprocess.
fd, report_name = tempfile.mkstemp(suffix=".json", prefix="pytest_report_")
os.close(fd)
report_path = Path(report_name)
@@ -114,14 +92,8 @@ def run(
timeout=_TIMEOUT_S,
)
except subprocess.TimeoutExpired:
- return (
- f"<error: pytest timed out after {_TIMEOUT_S}s on {target}>"
- )
+ return f"<error: pytest timed out after {_TIMEOUT_S}s on {target}>"
- # If the json-report plugin isn't loaded, pytest prints a
- # clear error and exits 4 (usage error). Detect that and
- # point the caller at the install step rather than handing
- # back an opaque exit code.
combined = (proc.stdout or "") + "\n" + (proc.stderr or "")
if "unrecognized arguments: --json-report" in combined:
return (
@@ -152,10 +124,6 @@ def _format_report(data: dict, target: str) -> str:
passed = summary.get("passed", 0)
failed = summary.get("failed", 0)
skipped = summary.get("skipped", 0)
- # pytest-json-report uses `error` (singular) in current versions;
- # the `errors` fallback is belt-and-suspenders for a hypothetical
- # schema rename. If/when we pin a minimum json-report version we
- # can drop one.
errors = summary.get("error", 0) + summary.get("errors", 0)
duration = data.get("duration") or 0.0
@@ -166,9 +134,7 @@ def _format_report(data: dict, target: str) -> str:
parts.append(f"{skipped} skipped")
if errors:
parts.append(f"{errors} errors")
- head = (
- f"pytest {target}: {', '.join(parts)} ({duration:.2f}s)"
- )
+ head = f"pytest {target}: {', '.join(parts)} ({duration:.2f}s)"
failure_blocks: list[str] = []
error_blocks: list[str] = []
@@ -177,25 +143,17 @@ def _format_report(data: dict, target: str) -> str:
if outcome not in ("failed", "error"):
continue
nodeid = t.get("nodeid", "?")
- # Failures live in the "call" phase; errors usually surface
- # in "setup" (fixture errors) or "teardown".
for phase in ("call", "setup", "teardown"):
stage = t.get(phase) or {}
if stage.get("outcome") == outcome:
msg = (stage.get("longrepr") or "").strip()
- # Last non-empty traceback line is usually the most
- # informative — show that plus the test id.
tail = ""
for ln in reversed(msg.splitlines()):
if ln.strip():
tail = ln.strip()
break
- bucket = (
- failure_blocks if outcome == "failed" else error_blocks
- )
- bucket.append(
- f"- {nodeid} ({phase})\n {tail}"
- )
+ bucket = failure_blocks if outcome == "failed" else error_blocks
+ bucket.append(f"- {nodeid} ({phase})\n {tail}")
break
body_parts: list[str] = []
@@ -209,9 +167,7 @@ def _format_report(data: dict, target: str) -> str:
f"(narrow with k=... to triage individually)"
)
if error_blocks:
- body_parts.append(
- "errors:\n" + "\n".join(error_blocks[:_MAX_FAILURES_SHOWN])
- )
+ body_parts.append("errors:\n" + "\n".join(error_blocks[:_MAX_FAILURES_SHOWN]))
if body_parts:
return head + "\n\n" + "\n\n".join(body_parts)
diff --git a/pyagent/plugins/py_dev_toolkit/python_env.py b/pyagent/plugins/py_dev_toolkit/python_env.py
index e1c7e1f..c38216d 100644
--- a/pyagent/plugins/py_dev_toolkit/python_env.py
+++ b/pyagent/plugins/py_dev_toolkit/python_env.py
@@ -27,7 +27,6 @@
from pyagent import venv as venv_mod
-
_WORKSPACE_PY_VERSION_TIMEOUT_S = 10
@@ -101,9 +100,7 @@ def python_env(scope: str = "workspace") -> str:
"""
scope = (scope or "workspace").strip().lower()
if scope not in ("workspace", "agent"):
- return (
- f"<error: scope must be 'workspace' or 'agent', got {scope!r}>"
- )
+ return f"<error: scope must be 'workspace' or 'agent', got {scope!r}>"
if scope == "workspace":
try:
@@ -124,9 +121,6 @@ def python_env(scope: str = "workspace") -> str:
}
)
- # scope == "agent": the venv pyagent is running under, if any.
- # `sys.prefix != sys.base_prefix` is the canonical "am I in a
- # venv" check; if not, we report honestly without creating.
in_venv = sys.prefix != sys.base_prefix
if not in_venv:
return json.dumps(
@@ -135,9 +129,7 @@ def python_env(scope: str = "workspace") -> str:
"venv_path": "",
"python": sys.executable,
"pip": "",
- "python_version": ".".join(
- map(str, sys.version_info[:3])
- ),
+ "python_version": ".".join(map(str, sys.version_info[:3])),
"exists_before_call": False,
"note": (
"pyagent is not running in a venv; "
@@ -149,13 +141,8 @@ def python_env(scope: str = "workspace") -> str:
)
agent_venv = Path(sys.prefix)
- # Use the canonical helpers so Linux/macOS/Windows all agree
- # on bin/Scripts naming, even though we already know
- # `sys.executable`.
python = venv_mod.python_path(agent_venv)
pip = venv_mod.pip_path(agent_venv)
- # `pip` may not be present in some minimal venvs — surface
- # that as a note rather than a hard error.
note = ""
if not pip.exists():
note = (
diff --git a/pyagent/plugins/py_dev_toolkit/typecheck.py b/pyagent/plugins/py_dev_toolkit/typecheck.py
index a333902..0644f2f 100644
--- a/pyagent/plugins/py_dev_toolkit/typecheck.py
+++ b/pyagent/plugins/py_dev_toolkit/typecheck.py
@@ -22,22 +22,8 @@
from pyagent import permissions
from pyagent.plugins.py_dev_toolkit._pathutil import shorten as _shorten
-_TIMEOUT_S = 120 # typecheckers are slower than linters; bump from 60.
-
-# Text-format mypy line: `path:line:col: severity: message [code]`.
-# `(?P<file>.+?)` is non-greedy so it accepts paths containing
-# colons — Windows drive letters (`C:\foo\bar.py:3:1: error: …`)
-# being the case that bit us. Earlier `[^:]+` silently dropped
-# every error on Windows, returning a false-clean result.
-#
-# Edge case the non-greedy match doesn't fully cover: a POSIX path
-# with a single colon followed by a digit (e.g. `dir:9file.py`)
-# could in principle confuse the engine. In practice it matches
-# correctly because the trailing `:\s+(error|note|warning):\s+`
-# anchor requires a real severity token after the second colon —
-# the engine backtracks until the file portion is the right shape.
-# Documented because the algorithmic guarantee isn't obvious from
-# the regex alone.
+_TIMEOUT_S = 120
+
_MYPY_TEXT_LINE = re.compile(
r"^(?P<file>.+?):(?P<line>\d+):(?P<col>\d+):\s+"
r"(?P<sev>error|note|warning):\s+(?P<msg>.*?)"
@@ -67,9 +53,7 @@ def run(path: str, tool: str = "mypy") -> str:
if not path or not str(path).strip():
return "<error: path is required>"
if tool not in ("mypy", "pyright"):
- return (
- f"<error: tool must be 'mypy' or 'pyright', got {tool!r}>"
- )
+ return f"<error: tool must be 'mypy' or 'pyright', got {tool!r}>"
target = Path(path)
if not target.exists():
@@ -109,14 +93,12 @@ def _run_mypy(binary: str, target: Path) -> str:
return _format("mypy", findings, str(target))
-def _try_mypy_json(
- binary: str, target: Path
-) -> tuple[list[dict], str | None] | None:
+def _try_mypy_json(binary: str, target: Path) -> tuple[list[dict], str | None] | None:
"""Try `mypy -O json`. Returns:
- - `(findings, None)` on success.
- - `(_, error_string)` when mypy ran but failed.
- - `None` when the JSON flag isn't recognized (older mypy);
- caller should fall back to text parsing.
+ - `(findings, None)` on success.
+ - `(_, error_string)` when mypy ran but failed.
+ - `None` when the JSON flag isn't recognized (older mypy);
+ caller should fall back to text parsing.
"""
try:
proc = subprocess.run(
@@ -128,25 +110,13 @@ def _try_mypy_json(
except subprocess.TimeoutExpired:
return [], f"<error: mypy timed out after {_TIMEOUT_S}s>"
- # Robustly detect "JSON flag not recognized" by inspecting the
- # *first non-empty stdout line* rather than substring-matching
- # mypy's error wording. If JSON is producing output, the first
- # non-empty line is a JSON object (`{...}`); anything else means
- # mypy printed a usage error or a localized message and we
- # should fall through to text parsing instead of trusting what
- # we got. This survives mypy reword / locale changes.
first = next(
(ln for ln in (proc.stdout or "").splitlines() if ln.strip()),
"",
).lstrip()
if first and not first.startswith("{"):
- return None # older mypy — fall back to text parsing
+ return None
- # mypy exits 1 when it finds errors — that's normal. Treat
- # exit > 1 as failure only if no JSON output came through; some
- # configurations print partial results plus a non-zero status
- # (plugin failures, etc.), and we'd rather surface what we got
- # than swallow it.
if proc.returncode > 1 and not first:
err = (proc.stderr or "").strip() or "(no stderr)"
return [], f"<error: mypy failed (exit {proc.returncode}): {err}>"
@@ -268,15 +238,13 @@ def _run_pyright(binary: str, target: Path) -> str:
diagnostics = data.get("generalDiagnostics") or []
findings: list[dict] = []
for d in diagnostics:
- # "information" / "hint" are pyright's equivalent of mypy
- # notes — context, not findings. Skip for the same reason.
if d.get("severity") in ("information", "hint"):
continue
rng = (d.get("range") or {}).get("start") or {}
findings.append(
{
"filename": d.get("file", "?"),
- "line": int(rng.get("line", 0)) + 1, # pyright is 0-based
+ "line": int(rng.get("line", 0)) + 1,
"col": int(rng.get("character", 0)) + 1,
"severity": d.get("severity", "error"),
"code": d.get("rule") or "",
@@ -300,8 +268,7 @@ def _format(tool: str, findings: list[dict], target: str) -> str:
f"{code_part}{f['message']}"
)
sev_part = ", ".join(
- f"{n} {sev}{'s' if n != 1 else ''}"
- for sev, n in sorted(by_sev.items())
+ f"{n} {sev}{'s' if n != 1 else ''}" for sev, n in sorted(by_sev.items())
)
summary = (
f"{tool}: {len(findings)} finding"
diff --git a/pyagent/plugins/reddit_search/__init__.py b/pyagent/plugins/reddit_search/__init__.py
index 62bddd2..1f86d75 100644
--- a/pyagent/plugins/reddit_search/__init__.py
+++ b/pyagent/plugins/reddit_search/__init__.py
@@ -37,16 +37,12 @@
import urllib.parse
import urllib.request
from dataclasses import dataclass
-from typing import Any
from pyagent.session import Attachment
logger = logging.getLogger(__name__)
-# Reddit subreddit names: alphanumeric + underscore, 1-21 chars.
-# Validating up front catches typos like "Python/comments/abc" that
-# would otherwise produce a 404 URL after path concatenation.
_SUBREDDIT_RE = re.compile(r"^[A-Za-z0-9_]{1,21}$")
@@ -55,7 +51,7 @@
"pyagent-reddit-search/0.1 (+https://github.com/derekwisong/pyagent)"
)
_DEFAULT_SAVE_STRUCTURED = True
-_MAX_RESULTS = 25 # Reddit caps at 100 per page; we cap lower to keep results focused
+_MAX_RESULTS = 25
_VALID_TIME_WINDOWS = {"hour", "day", "week", "month", "year", "all"}
_VALID_SORTS = {"relevance", "hot", "top", "new", "comments"}
@@ -65,14 +61,14 @@ class RedditPost:
"""One Reddit search result, normalized."""
title: str
- url: str # external URL the post links to (or self-permalink for text posts)
- permalink: str # reddit.com permalink — always present
+ url: str
+ permalink: str
subreddit: str
author: str
score: int
num_comments: int
created_utc: float
- selftext_excerpt: str # first ~300 chars of self-post body, "" for link posts
+ selftext_excerpt: str
def _resolve_timeout(plugin_cfg: dict) -> int:
@@ -109,9 +105,7 @@ def _config_warnings(plugin_cfg: dict) -> list[str]:
if "user_agent" in plugin_cfg:
raw = plugin_cfg["user_agent"]
if not isinstance(raw, str) or not raw.strip():
- out.append(
- f"user_agent must be a non-empty string — using default"
- )
+ out.append("user_agent must be a non-empty string — using default")
if "save_structured" in plugin_cfg:
raw = plugin_cfg["save_structured"]
if not isinstance(raw, bool):
@@ -143,9 +137,7 @@ def _build_url(
"raw_json": "1",
}
if subreddit:
- # Restrict to that sub specifically; without this, Reddit's
- # /r/<sub>/search.json silently spans all of Reddit on some
- # paths.
+ # Without restrict_sr=1, /r/<sub>/search.json silently spans all of Reddit on some paths.
params["restrict_sr"] = "1"
return f"{base}?{urllib.parse.urlencode(params)}"
@@ -167,9 +159,7 @@ def _parse_listing(payload: dict) -> list[RedditPost]:
)
external_url = str(d.get("url") or permalink).strip()
selftext = str(d.get("selftext") or "").strip()
- excerpt = (
- (selftext[:297] + "...") if len(selftext) > 300 else selftext
- )
+ excerpt = (selftext[:297] + "...") if len(selftext) > 300 else selftext
try:
score = int(d.get("score") or 0)
except (TypeError, ValueError):
@@ -225,9 +215,7 @@ def reddit_text_search(
return _parse_listing(payload)
-def format_results(
- posts: list[RedditPost], query: str, subreddit: str | None
-) -> str:
+def format_results(posts: list[RedditPost], query: str, subreddit: str | None) -> str:
"""Render a list of RedditPost as a markdown numbered list."""
if not posts:
scope = f" in r/{subreddit}" if subreddit else ""
@@ -330,8 +318,7 @@ def reddit_search(
)
if sort not in _VALID_SORTS:
return (
- f"<error: sort must be one of {sorted(_VALID_SORTS)}, "
- f"got {sort!r}>"
+ f"<error: sort must be one of {sorted(_VALID_SORTS)}, " f"got {sort!r}>"
)
cfg = api.plugin_config or {}
@@ -351,13 +338,10 @@ def reddit_search(
)
except urllib.error.HTTPError as e:
if e.code == 429:
- # 429 from Reddit usually means pacing or OAuth, not
- # User-Agent shape — earlier wording overstated the
- # UA fix per #94 review.
return (
- f"<reddit-search error: rate limited (HTTP 429); "
- f"back off — persistent 429s usually need pacing "
- f"or OAuth, not user_agent changes>"
+ "<reddit-search error: rate limited (HTTP 429); "
+ "back off — persistent 429s usually need pacing "
+ "or OAuth, not user_agent changes>"
)
return f"<reddit-search error: HTTP {e.code}: {e.reason}>"
except urllib.error.URLError as e:
@@ -393,7 +377,4 @@ def reddit_search(
suffix=".json",
)
- # Role-only: keeps reddit_search out of the root agent's schema.
- # Allowlisted in the bundled researcher role; reach for it via
- # `pyagent --role researcher` or spawn_subagent.
api.register_tool("reddit_search", reddit_search, role_only=True)
diff --git a/pyagent/plugins/strategic_reevaluation/__init__.py b/pyagent/plugins/strategic_reevaluation/__init__.py
index f9b45c9..dfd75a3 100644
--- a/pyagent/plugins/strategic_reevaluation/__init__.py
+++ b/pyagent/plugins/strategic_reevaluation/__init__.py
@@ -36,8 +36,6 @@
CONSECUTIVE_FAILURE_THRESHOLD = 3
-# Per-process state. The plugin is `in_subagents = false`, so this
-# only ever lives in the root agent's process.
_consecutive_fails: dict[str, int] = {}
@@ -65,26 +63,19 @@ def _on_after_tool(
if path is None:
return None
if name != "edit_file":
- # Reset the counter on any other tool against this path —
- # evidence the agent is inspecting rather than blind-
- # retrying.
_consecutive_fails.pop(path, None)
return None
if not is_error:
- # Successful edit. Reset.
_consecutive_fails.pop(path, None)
return None
- # Bumping the counter.
n = _consecutive_fails.get(path, 0) + 1
_consecutive_fails[path] = n
if n < CONSECUTIVE_FAILURE_THRESHOLD:
return None
- # Threshold tripped. Reset so the note doesn't fire on every
- # subsequent failure too — the agent gets one nudge, not a
- # spammy stream.
+ # Reset after firing so the agent gets one nudge, not a stream.
_consecutive_fails.pop(path, None)
return AfterToolHookResult(
extra_user_message=(
@@ -99,6 +90,6 @@ def register(api: Any) -> None:
def _reset_for_tests() -> None:
- """Clear the per-path counter. Called by smoke tests so each test
+ """Clear the per-path counter. Called by tests so each test
starts from a known state."""
_consecutive_fails.clear()
diff --git a/pyagent/plugins/web_search/__init__.py b/pyagent/plugins/web_search/__init__.py
index d875cf2..ecac1e0 100644
--- a/pyagent/plugins/web_search/__init__.py
+++ b/pyagent/plugins/web_search/__init__.py
@@ -44,22 +44,13 @@
from __future__ import annotations
import json
-from typing import Sequence
+from collections.abc import Sequence
from pyagent.plugins.web_search import search as _search
from pyagent.session import Attachment
-
-# Maximum results the agent is allowed to ask for in one call. DDG
-# starts rate-limiting around the high 20s in practice; cap is a
-# safety belt rather than the everyday limit.
_MAX_RESULTS = 25
-# Side-save the structured SearchResult list to attachments by
-# default. Cost is ~3KB per call; benefit is downstream tools can
-# consume the URL list without re-running the search, and the agent
-# has a recovery path if it forgets which URLs it saw. Configurable
-# via [plugins.web-search] save_structured.
_DEFAULT_SAVE_STRUCTURED = True
@@ -131,10 +122,9 @@ def _config_warnings(plugin_cfg: dict) -> list[str]:
)
else:
bad = [
- v for v in raw
- if not isinstance(v, (int, float))
- or isinstance(v, bool)
- or v < 0
+ v
+ for v in raw
+ if not isinstance(v, (int, float)) or isinstance(v, bool) or v < 0
]
if bad:
out.append(
@@ -165,10 +155,6 @@ def _config_warnings(plugin_cfg: dict) -> list[str]:
def register(api):
- # Lightweight register-time validation of the [plugins.web-search]
- # table. Bogus values still fall through to defaults at call time
- # via the _resolve_* helpers — this is purely about surfacing
- # config typos at startup instead of letting them sit silent.
for warning in _config_warnings(api.plugin_config or {}):
api.log("warning", warning)
@@ -220,14 +206,10 @@ def web_search(query: str, n: int = 10):
)
except ImportError:
return (
- "<search error: ddgs package not installed — "
- "run: pip install ddgs>"
+ "<search error: ddgs package not installed — " "run: pip install ddgs>"
)
except _search.SearchRateLimited as e:
- return (
- f"<search error: rate limited; pause and try again "
- f"later ({e})>"
- )
+ return f"<search error: rate limited; pause and try again " f"later ({e})>"
except _search.SearchBackoffExhausted as e:
return (
f"<search error: backend unavailable {e}; try a "
@@ -237,18 +219,11 @@ def web_search(query: str, n: int = 10):
return f"<search error: {e}>"
markdown = _search.format_search_results(results, query)
- # Empty-results path: format_search_results returned the
- # `<no results ...>` marker. Nothing structurally useful to
- # save; return the marker as a plain string so error/empty
- # behavior stays consistent.
if not save_structured or not results:
return markdown
structured = json.dumps(
- [
- {"title": r.title, "url": r.url, "snippet": r.snippet}
- for r in results
- ],
+ [{"title": r.title, "url": r.url, "snippet": r.snippet} for r in results],
indent=2,
ensure_ascii=False,
)
@@ -258,8 +233,4 @@ def web_search(query: str, n: int = 10):
suffix=".json",
)
- # Role-only: keeps web_search out of the root agent's schema
- # list. Reach for it via `pyagent --role researcher` (or
- # spawn_subagent(role="researcher", ...)) — the bundled
- # researcher role's allowlist names it explicitly.
api.register_tool("web_search", web_search, role_only=True)
diff --git a/pyagent/plugins/web_search/search.py b/pyagent/plugins/web_search/search.py
index 40ad621..661af79 100644
--- a/pyagent/plugins/web_search/search.py
+++ b/pyagent/plugins/web_search/search.py
@@ -11,13 +11,11 @@
import logging
import time
from dataclasses import dataclass
-from typing import Sequence
+from collections.abc import Sequence
logger = logging.getLogger(__name__)
-# Retry policy defaults. These are overridable via [plugins.web-search]
-# in config.toml — see web_search/__init__.py for the resolver.
_DEFAULT_ATTEMPTS = 3
_DEFAULT_BACKOFF_S: tuple[float, ...] = (1.0, 3.0)
_DEFAULT_BACKEND = "auto"
@@ -88,8 +86,6 @@ def ddg_text_search(
engines all returned no results (a successful empty result;
not a retried failure).
"""
- # Local import so an environment missing `ddgs` still loads the
- # plugin module (the tool will return a clean error when called).
from ddgs import DDGS
from ddgs.exceptions import (
DDGSException,
@@ -105,18 +101,11 @@ def ddg_text_search(
try:
results = DDGS().text(query, max_results=n, backend=backend)
except RatelimitException as e:
- # Don't retry — the upstream is explicitly throttling.
- # The caller surfaces a distinct marker so the agent can
- # back off rather than re-fire the same query.
raise SearchRateLimited(str(e)) from e
except (TimeoutException, DDGSException) as e:
last_err = e
- logger.info(
- "web_search attempt %d/%d failed: %s", i + 1, attempts, e
- )
+ logger.info("web_search attempt %d/%d failed: %s", i + 1, attempts, e)
if i < attempts - 1:
- # Sleep before the next attempt. backoff_s shorter
- # than attempts-1 reuses the last value.
if backoff_s:
delay = backoff_s[min(i, len(backoff_s) - 1)]
else:
@@ -135,12 +124,6 @@ def ddg_text_search(
)
)
if not out:
- # Empty result with no exception is the silent-break
- # signature — could be a genuine niche query or scraper
- # drift after a DDG HTML change. The agent gets the
- # `<no results>` marker either way; the warning lets
- # an operator notice the pattern in logs (and tells
- # them to check whether ddgs needs an update).
logger.warning(
"web_search: backend %r returned 0 results for "
"%r — may be a niche query or scraper drift",
@@ -149,16 +132,10 @@ def ddg_text_search(
)
return out
- # All attempts exhausted. last_err is set because we only land
- # here if the loop body raised on every iteration.
- raise SearchBackoffExhausted(
- f"after {attempts} attempt(s): {last_err}"
- )
+ raise SearchBackoffExhausted(f"after {attempts} attempt(s): {last_err}")
-def format_search_results(
- results: list[SearchResult], query: str
-) -> str:
+def format_search_results(results: list[SearchResult], query: str) -> str:
"""Render a list of `SearchResult` as a markdown numbered list.
Empty input yields a `<no results ...>` marker so the agent can
@@ -173,9 +150,6 @@ def format_search_results(
if r.snippet:
lines.append(f" {r.snippet}")
lines.append("")
- # Drop a trailing blank line for cleanliness.
while lines and lines[-1] == "":
lines.pop()
return "\n".join(lines)
-
-
diff --git a/pyagent/plugins_cli.py b/pyagent/plugins_cli.py
index 40a94b9..af9c58b 100644
--- a/pyagent/plugins_cli.py
+++ b/pyagent/plugins_cli.py
@@ -56,13 +56,9 @@ def list_cmd() -> None:
if not record.enabled:
tags.append("disabled")
if record.shadowed_by:
- tags.append(
- f"overrides {len(record.shadowed_by)} earlier tier(s)"
- )
+ tags.append(f"overrides {len(record.shadowed_by)} earlier tier(s)")
tools = ", ".join(m.provides_tools) or "(no tools)"
- click.echo(
- f" {m.name} [{', '.join(tags)}]: {m.description}"
- )
+ click.echo(f" {m.name} [{', '.join(tags)}]: {m.description}")
click.echo(f" tools: {tools}")
if record.shadowed_by:
for path in record.shadowed_by:
diff --git a/pyagent/pricing.py b/pyagent/pricing.py
index 07642a3..397b5f6 100644
--- a/pyagent/pricing.py
+++ b/pyagent/pricing.py
@@ -12,9 +12,7 @@
from pyagent import llms
-
-# USD per million tokens, (input, output). Models not listed get
-# token-only display, no $ amount. Update freely as pricing changes.
+# USD per million tokens, (input, output).
PRICING_USD_PER_MTOK: dict[str, tuple[float, float]] = {
"claude-opus-4-7": (15.0, 75.0),
"claude-sonnet-4-6": (3.0, 15.0),
@@ -24,8 +22,6 @@
"gemini-2.5-flash": (0.075, 0.30),
}
-# Anthropic ephemeral-cache pricing multipliers applied to the model's
-# base input rate: writes are 1.25× input, reads are 0.1× input.
ANTHROPIC_CACHE_WRITE_MULT = 1.25
ANTHROPIC_CACHE_READ_MULT = 0.1
@@ -108,12 +104,7 @@ def gross_net_tokens(
"""
name = model_name(model)
if is_anthropic_model(name):
- gross = (
- input_tokens
- + output_tokens
- + cache_creation_tokens
- + cache_read_tokens
- )
+ gross = input_tokens + output_tokens + cache_creation_tokens + cache_read_tokens
net = (
input_tokens
+ output_tokens
diff --git a/pyagent/prompts.py b/pyagent/prompts.py
index 90a1bbf..b47de53 100644
--- a/pyagent/prompts.py
+++ b/pyagent/prompts.py
@@ -37,7 +37,8 @@
import platform
from datetime import date
from pathlib import Path
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING
+from collections.abc import Callable
if TYPE_CHECKING:
from pyagent.plugins import LoadedPlugins, PromptContext
@@ -62,7 +63,7 @@ def __init__(
roles_catalog: str | Callable[[], str] = "",
role_body: str = "",
task_body: str = "",
- plugin_loader: "LoadedPlugins | None" = None,
+ plugin_loader: LoadedPlugins | None = None,
include_soul: bool = True,
) -> None:
self.soul = Path(soul)
@@ -73,15 +74,9 @@ def __init__(
self.role_body = role_body
self.task_body = task_body
self.plugin_loader = plugin_loader
- # SOUL is the root-conversation persona — voice, "How you
- # work", memory framing. Subagents take their voice from
- # their role file (or model defaults), so they pass
- # include_soul=False and skip SOUL entirely. The behavior
- # floor (Core Directives, "You are Never") lives in PRIMER
- # which everyone loads.
self.include_soul = include_soul
- def build(self, ctx: "PromptContext | None" = None) -> str:
+ def build(self, ctx: PromptContext | None = None) -> str:
"""Concatenated stable+volatile segments. Use only when cache
placement doesn't matter (e.g. tests, legacy callers)."""
stable, volatile = self.build_segments(ctx)
@@ -89,9 +84,7 @@ def build(self, ctx: "PromptContext | None" = None) -> str:
return f"{stable}\n\n{volatile}"
return stable
- def build_segments(
- self, ctx: "PromptContext | None" = None
- ) -> tuple[str, str]:
+ def build_segments(self, ctx: PromptContext | None = None) -> tuple[str, str]:
"""Return (stable, volatile) — the two halves of the system
prompt around the cache breakpoint."""
from pyagent.plugins import PromptContext as _PromptContext
@@ -116,9 +109,7 @@ def build_segments(
sections.append(skills)
roles = (
- self.roles_catalog()
- if callable(self.roles_catalog)
- else self.roles_catalog
+ self.roles_catalog() if callable(self.roles_catalog) else self.roles_catalog
)
if roles:
sections.append(roles)
@@ -126,16 +117,12 @@ def build_segments(
if self.task_body:
sections.append(self.task_body)
- # Plugin-contributed sections, split by `volatile`.
volatile_sections: list[str] = []
if self.plugin_loader is not None:
for section in self.plugin_loader.sections():
try:
rendered = section.renderer(ctx)
except Exception:
- # A renderer raising is the plugin's bug; log and
- # skip its contribution this turn rather than
- # wedging the agent.
import logging
logging.getLogger(__name__).exception(
@@ -151,11 +138,6 @@ def build_segments(
else:
sections.append(rendered)
- # USER ledger auto-load was here pre-plugin; now owned by the
- # memory plugin's "user-ledger" prompt section. With the
- # plugin disabled, USER content does not appear in the system
- # prompt at all — that is the clean-replacement contract.
-
sections.append(self._persona_footer())
stable = "\n\n".join(s.rstrip() for s in sections)
@@ -167,10 +149,9 @@ def _persona_footer(self) -> str:
shell_path = os.environ.get("SHELL") or os.environ.get("COMSPEC") or ""
shell = Path(shell_path).name if shell_path else "unknown"
os_label = f"{platform.system()} {platform.release()}".strip() or "unknown"
- # Re-discovered each turn so a venv created mid-session shows up
- # without restart. Lazy import dodges the prompts → venv → ...
- # cycle and keeps the import surface narrow.
+ # Lazy import dodges the prompts -> venv -> ... import cycle.
from pyagent import venv as venv_mod
+
venv_line = venv_mod.describe(Path(os.getcwd()))
return (
"## Environment\n"
@@ -188,11 +169,7 @@ def _persona_footer(self) -> str:
"initiative — self-modification without an ask is drift, "
"not a feature. When the user asks (even casually), go "
"ahead.\n"
- + (
- f"- SOUL: {self.soul.resolve()}\n"
- if self.include_soul
- else ""
- )
+ + (f"- SOUL: {self.soul.resolve()}\n" if self.include_soul else "")
+ f"- TOOLS: {self.tools.resolve()}\n"
f"- PRIMER: {self.primer.resolve()}"
)
diff --git a/pyagent/roles.py b/pyagent/roles.py
index 1e31b41..679a960 100644
--- a/pyagent/roles.py
+++ b/pyagent/roles.py
@@ -98,17 +98,11 @@ class Role:
source: Path | None = None
-# ---- Name normalization ---------------------------------------------
-
-
def _normalize_name(raw: str) -> str:
"""Canonicalize a role name: lowercase, dashes → underscores."""
return raw.replace("-", "_").lower()
-# ---- Frontmatter parsing --------------------------------------------
-
-
_FRONTMATTER_RE = re.compile(
r"\A\+\+\+[ \t]*\r?\n(.*?)\r?\n\+\+\+[ \t]*\r?\n?",
re.DOTALL,
@@ -126,10 +120,9 @@ def _parse_frontmatter(text: str) -> tuple[dict[str, Any], str]:
return {}, text
m = _FRONTMATTER_RE.match(text)
if not m:
- # Has opening +++ but no closing one — let the prose render.
return {}, text
fm_text = m.group(1)
- body = text[m.end():].lstrip("\n")
+ body = text[m.end() :].lstrip("\n")
try:
fm = tomllib.loads(fm_text)
except tomllib.TOMLDecodeError as e:
@@ -140,9 +133,6 @@ def _parse_frontmatter(text: str) -> tuple[dict[str, Any], str]:
return fm, body
-# ---- Description auto-derivation ------------------------------------
-
-
_HEADING_RE = re.compile(r"^\s*#+\s.*$", re.MULTILINE)
@@ -157,16 +147,13 @@ def _derive_description(name: str, body: str) -> str:
if not body.strip():
return name
lines = body.splitlines()
- # Skip a leading heading (or chain of blank lines + heading).
i = 0
while i < len(lines) and not lines[i].strip():
i += 1
if i < len(lines) and lines[i].lstrip().startswith("#"):
i += 1
- # Skip blanks after the heading.
while i < len(lines) and not lines[i].strip():
i += 1
- # Collect the first paragraph (until the next blank line).
para: list[str] = []
while i < len(lines) and lines[i].strip():
para.append(lines[i].strip())
@@ -176,15 +163,11 @@ def _derive_description(name: str, body: str) -> str:
text = " ".join(para)
text = re.sub(r"\s+", " ", text).strip()
if len(text) > _DESCRIPTION_CAP:
- # Cut on a word boundary if convenient.
- cut = text[: _DESCRIPTION_CAP].rsplit(" ", 1)[0]
- text = (cut or text[: _DESCRIPTION_CAP]).rstrip(",.;:") + "…"
+ cut = text[:_DESCRIPTION_CAP].rsplit(" ", 1)[0]
+ text = (cut or text[:_DESCRIPTION_CAP]).rstrip(",.;:") + "…"
return text
-# ---- Coercion helpers -----------------------------------------------
-
-
def _coerce_tools(name: str, raw: Any) -> tuple[str, ...] | None:
if raw is None:
return None
@@ -199,9 +182,7 @@ def _coerce_meta_tools(name: str, raw: Any) -> bool:
return True
if isinstance(raw, bool):
return raw
- logger.warning(
- "role %r meta_tools must be bool; defaulting to True", name
- )
+ logger.warning("role %r meta_tools must be bool; defaulting to True", name)
return True
@@ -216,9 +197,6 @@ def _coerce_model(name: str, raw: Any) -> str:
return llms.resolve_model(raw)
-# ---- File-tier loading ----------------------------------------------
-
-
def _load_role_file(md_path: Path) -> Role | None:
"""Parse one `.md` file into a Role. Returns None on read errors."""
try:
@@ -276,9 +254,6 @@ def _bundled_root() -> Path | None:
return None
-# ---- Legacy [models.<name>] backward-compat -------------------------
-
-
def _coerce_legacy_body(name: str, body: str, body_path: str) -> str:
if body and body_path:
logger.warning(
@@ -299,7 +274,9 @@ def _coerce_legacy_body(name: str, body: str, body_path: str) -> str:
except OSError as e:
logger.warning(
"role %r system_prompt_path %s unreadable: %s",
- name, body_path, e,
+ name,
+ body_path,
+ e,
)
return ""
@@ -373,9 +350,6 @@ def _reset_deprecation_warning() -> None:
_DEPRECATION_WARNED = False
-# ---- Public API -----------------------------------------------------
-
-
def load() -> dict[str, Role]:
"""Return the dict of all defined roles, indexed by canonical name.
@@ -391,9 +365,6 @@ def load() -> dict[str, Role]:
if bundled_root is not None:
roles.update(_scan_dir(bundled_root))
- # Legacy TOML form: lower than file-based tiers, higher than
- # bundled (so a user can shadow a bundled role with a TOML entry
- # if they really want, though we don't recommend it).
roles.update(_legacy_roles())
roles.update(_scan_dir(paths.config_dir() / "roles"))
diff --git a/pyagent/roles_bundled/PYTHON_ENGINEER.md b/pyagent/roles_bundled/PYTHON_ENGINEER.md
index e49cbb4..77f9300 100644
--- a/pyagent/roles_bundled/PYTHON_ENGINEER.md
+++ b/pyagent/roles_bundled/PYTHON_ENGINEER.md
@@ -92,7 +92,7 @@ the code stays).
## Tests
-If a smoke or unit suite covers the area you touched, run it
+If a test suite covers the area you touched, run it
before and after. If your change breaks something that looks
unrelated, **stop**. Don't paper over it; report the breakage in
your reply, with the failing test name and message, and let the
@@ -100,7 +100,7 @@ caller decide.
For new behavior, write a test alongside the implementation.
Mirror the project's framework — pytest fixtures, unittest
-classes, plain assert scripts under `tests/smoke_*.py` —
+classes, plain assert scripts under `tests/test_*.py` —
whichever the existing tests use. New scaffolding goes in a
separate PR.
@@ -123,7 +123,7 @@ your reply.
- **Why.** A line or two on non-trivial decisions. Skip for
obvious fixes.
- **Ran.** Tests, lint, typecheck — name the commands and the
- outcomes. `pytest tests/smoke_foo.py: 12 passed`. If you didn't
+ outcomes. `pytest tests/test_foo.py: 12 passed`. If you didn't
run something the task implies you should have, say why.
- **Open.** Anything still uncertain. TODOs you saw and skipped.
Scope expansions you considered and rejected, briefly, so the
diff --git a/pyagent/roles_bundled/SOFTWARE_ENGINEER.md b/pyagent/roles_bundled/SOFTWARE_ENGINEER.md
index 9b4c35b..3be7c79 100644
--- a/pyagent/roles_bundled/SOFTWARE_ENGINEER.md
+++ b/pyagent/roles_bundled/SOFTWARE_ENGINEER.md
@@ -31,7 +31,7 @@ existing patterns, then make the smallest change that satisfies the
task. Match the surrounding style; don't rewrite a module's
conventions to suit your taste.
-Run the tests. If a smoke or unit suite exists for the area you're
+Run the tests. If a test suite exists for the area you're
touching, run it before and after your change. If your change breaks
something unrelated, stop and ask — don't paper over it.
diff --git a/pyagent/roles_cli.py b/pyagent/roles_cli.py
index 6740607..c2a2e32 100644
--- a/pyagent/roles_cli.py
+++ b/pyagent/roles_cli.py
@@ -42,11 +42,7 @@ def _project_root() -> Path:
@click.group()
def main() -> None:
"""Inspect, seed, and migrate pyagent roles."""
- # Surface roles-module warnings (e.g. legacy [models.<name>]) to
- # stderr so `pyagent-roles list` actually shows them.
- logging.basicConfig(
- level=logging.WARNING, format="%(levelname)s: %(message)s"
- )
+ logging.basicConfig(level=logging.WARNING, format="%(levelname)s: %(message)s")
def _render_tier(label: str, root: Path | None, roles: dict) -> None:
@@ -63,9 +59,7 @@ def _render_tier(label: str, root: Path | None, roles: dict) -> None:
def list_cmd() -> None:
"""List roles across all three tiers (plus any legacy TOML roles)."""
bundled_root = roles_mod._bundled_root()
- bundled = (
- roles_mod._scan_dir(bundled_root) if bundled_root else {}
- )
+ bundled = roles_mod._scan_dir(bundled_root) if bundled_root else {}
user = roles_mod._scan_dir(_user_root())
project = roles_mod._scan_dir(_project_root())
legacy = roles_mod._legacy_roles()
@@ -104,14 +98,14 @@ def show_cmd(name: str) -> None:
normalized = roles_mod._normalize_name(name)
role = roles_mod.load().get(normalized)
if role is None:
- raise click.ClickException(
- f"no role named {name!r}; try `pyagent-roles list`."
- )
+ raise click.ClickException(f"no role named {name!r}; try `pyagent-roles list`.")
src = str(role.source) if role.source else "(legacy: config.toml [models.*])"
click.echo(f"# name: {role.name}")
click.echo(f"# source: {src}")
click.echo(f"# model: {role.model or '(inherits parent)'}")
- click.echo(f"# tools: {list(role.tools) if role.tools is not None else '(default set)'}")
+ click.echo(
+ f"# tools: {list(role.tools) if role.tools is not None else '(default set)'}"
+ )
click.echo(f"# meta_tools: {role.meta_tools}")
click.echo(f"# description: {role.description}")
click.echo()
@@ -125,9 +119,7 @@ def path_cmd(name: str) -> None:
normalized = roles_mod._normalize_name(name)
role = roles_mod.load().get(normalized)
if role is None:
- raise click.ClickException(
- f"no role named {name!r}; try `pyagent-roles list`."
- )
+ raise click.ClickException(f"no role named {name!r}; try `pyagent-roles list`.")
if role.source is None:
raise click.ClickException(
f"role {name!r} comes from config.toml [models.*]; "
@@ -205,7 +197,6 @@ def _render_migrated_role(role: roles_mod.Role, original_name: str) -> str:
if role.meta_tools is not True:
fm_lines.append(f"meta_tools = {_toml_value(role.meta_tools)}")
if not body:
- # No body to auto-derive from — pin the description explicitly.
fm_lines.append(f"description = {_toml_value(role.description)}")
fm_lines.append("+++")
if not body:
@@ -245,10 +236,6 @@ def migrate_cmd(force: bool) -> None:
role = roles_mod._coerce_legacy_role(name, entry)
if role is None:
continue
- # Filename mirrors the bundled all-caps + underscores convention:
- # legacy `[models.deep-thought]` → DEEP_THOUGHT.md (not
- # DEEP-THOUGHT.md). Lookup normalization treats both equivalently
- # but consistent filenames keep `pyagent-roles list` tidy.
canonical = name.upper().replace("-", "_")
dest = target_root / f"{canonical}.md"
if dest.exists() and not force:
diff --git a/pyagent/session.py b/pyagent/session.py
index d28e5c6..6ac56be 100644
--- a/pyagent/session.py
+++ b/pyagent/session.py
@@ -12,7 +12,7 @@
import logging
import uuid
from dataclasses import dataclass
-from datetime import date, datetime, timezone
+from datetime import UTC, date, datetime
from pathlib import Path
from typing import Any
@@ -53,10 +53,7 @@ class Session:
DEFAULT_ROOT = Path(".pyagent/sessions")
attachment_threshold = 8000
preview_chars = 1000
- # Soft cap on total attachments-dir size, in megabytes. After each
- # write, if the dir exceeds this we evict least-recently-accessed
- # files (atime, mtime fallback) until under the cap. The just-
- # written file is always preserved. 0 disables eviction entirely.
+ # Soft cap on attachments-dir size in MB; 0 disables LRU eviction.
attachment_dir_cap_mb: int = 25
def __init__(
@@ -71,10 +68,6 @@ def __init__(
self.attachments_dir = self.dir / "attachments"
self.conversation_path = self.dir / "conversation.jsonl"
if attachment_dir_cap_mb is not None:
- # Per-instance override of the class-level default. Keeps
- # the class attribute as the single source of truth for the
- # default while letting config wiring inject a different
- # cap without subclassing.
self.attachment_dir_cap_mb = attachment_dir_cap_mb
@classmethod
@@ -89,7 +82,9 @@ def list_ids(cls, root: Path | None = None) -> list[str]:
@classmethod
def _unique_id(cls, root: Path) -> str:
for _ in range(10):
- sid = f"{date.today().isoformat()}-{petname.generate(words=2, separator='-')}"
+ sid = (
+ f"{date.today().isoformat()}-{petname.generate(words=2, separator='-')}"
+ )
if not (root / sid).exists():
return sid
raise RuntimeError("could not generate a unique session id after 10 tries")
@@ -123,7 +118,7 @@ def append_history(self, entries: list[Any]) -> None:
if not entries:
return
self._ensure_dirs()
- ts = datetime.now(timezone.utc).isoformat(timespec="microseconds")
+ ts = datetime.now(UTC).isoformat(timespec="microseconds")
with self.conversation_path.open("a") as f:
for entry in entries:
if isinstance(entry, dict) and "ts" not in entry:
@@ -141,20 +136,11 @@ def write_attachment(
self._ensure_dirs()
if not suffix:
suffix = ".txt" if isinstance(content, str) else ".bin"
- # 8-char uuid suffix is collision-proof across concurrent processes
- # resuming the same session, and the dir listing still groups by tool.
- path = (
- self.attachments_dir
- / f"{tool_name}-{uuid.uuid4().hex[:8]}{suffix}"
- )
+ path = self.attachments_dir / f"{tool_name}-{uuid.uuid4().hex[:8]}{suffix}"
if isinstance(content, bytes):
path.write_bytes(content)
else:
path.write_text(content)
- # After every write, run LRU eviction if the dir is over cap.
- # The just-written `path` is always exempt — even a single
- # write that exceeds the cap by itself stays put (we evict
- # everything older first, then stop). cap=0 disables eviction.
if self.attachment_dir_cap_mb > 0:
self._evict_lru_until_under_cap(exclude=path)
return path
@@ -191,9 +177,6 @@ def _evict_lru_until_under_cap(self, exclude: Path) -> int:
if not self.attachments_dir.exists():
return 0
- # Collect (atime, size, path) for everything in the dir. We
- # gather sizes up front so the running total is stable as we
- # unlink — no re-stat per iteration.
entries: list[tuple[float, int, Path]] = []
total = 0
try:
@@ -213,9 +196,8 @@ def _evict_lru_until_under_cap(self, exclude: Path) -> int:
if total <= cap_bytes:
return 0
- # Sort oldest-atime first. Tie-break by size descending so a
- # cluster of same-atime files (common on noatime fs) prefers
- # to drop bigger ones first — fewer evictions to get under.
+ # Oldest-atime first; tie-break by size descending so noatime
+ # filesystems still evict the biggest stale file first.
entries.sort(key=lambda e: (e[0], -e[1]))
evicted = 0
@@ -247,17 +229,14 @@ def find_orphan_attachments(self) -> list[Path]:
if not self.attachments_dir.exists() or not self.conversation_path.exists():
return []
log_text = self.conversation_path.read_text()
- # Anchor with the "attachments/" segment so a bare filename can't
- # accidentally match unrelated content elsewhere in the log.
+ # Anchor on "attachments/" so a bare filename can't match elsewhere.
return [
f
for f in self.attachments_dir.iterdir()
if f.is_file() and f"attachments/{f.name}" not in log_text
]
- def purge_orphan_attachments(
- self, orphans: list[Path] | None = None
- ) -> int:
+ def purge_orphan_attachments(self, orphans: list[Path] | None = None) -> int:
"""Delete orphan attachments and return the count removed.
Pass `orphans` to skip the rescan if the caller already has the
diff --git a/pyagent/sessions_audit.py b/pyagent/sessions_audit.py
index 2038e20..0beea3d 100644
--- a/pyagent/sessions_audit.py
+++ b/pyagent/sessions_audit.py
@@ -26,13 +26,8 @@
from pyagent import pricing
-
-# Matches the prefix produced by `Agent._format_offload_ref` (issue #82
-# changed the header from prose to structured tokens). Captures the
-# attachment path and its char count. Anchored to the start of the
-# tool-result content; unanchored matching would catch the substring
-# inside an inline tool result that happens to mention an attachment,
-# inflating the offload count.
+# Anchored to the start of the tool-result content so an inline mention
+# of an attachment doesn't falsely register as an offload header.
_OFFLOAD_RE = re.compile(r"^\[offload (\S+) \| produced (\d+)c")
@@ -58,7 +53,7 @@ class BloatRow:
turn_idx: int
tool_name: str
char_count: int
- preview: str # first ~200 chars, newlines collapsed
+ preview: str
@dataclass
@@ -69,9 +64,6 @@ class AuditReport:
total_tokens: dict[str, int] = field(default_factory=dict)
total_cost_usd: float | None = None
cost_is_lower_bound: bool = False
- # Number of assistant turns whose `usage` dict lacked cache fields
- # (pre-#15 sessions). The renderer uses this for an "X of Y" warning
- # so the user can judge how much the cost number is missing.
pre_15_turns: int = 0
per_turn: list[TurnRow] = field(default_factory=list)
attachments: list[AttachmentRow] = field(default_factory=list)
@@ -147,21 +139,11 @@ def audit_session(
attachment_refs: dict[str, int] = {}
cost_is_lower_bound = False
- # turn_idx counts user→assistant exchanges by assistant-turn order
- # (1-indexed). Inline-bloat rows are tagged with the turn the tool
- # result LANDED in, which is the next assistant turn (since tool
- # results are in a user-role message that precedes the assistant's
- # follow-up). Approximation: we tag with the assistant index just
- # seen, which is what the human cares about for "blame which turn".
last_assistant_idx = 0
pre_15_turns = 0
totals = {"input": 0, "output": 0, "cache_creation": 0, "cache_read": 0}
- # Per-turn cost runs through the turn's RECORDED model (added to
- # usage by the LLM clients in the bench-followups PR), falling back
- # to the function arg for older sessions. Aggregating per-turn
- # costs (vs. multiplying summed tokens by one model's rates) is the
- # only way to stay correct across a session that spanned multiple
- # models — e.g. the user switched via /model partway through.
+ # Aggregate by summing per-turn costs (not by pricing summed tokens)
+ # so a session that switched models mid-stream stays correct.
per_turn_costs_sum = 0.0
any_cost_priced = False
recorded_models: list[str] = []
@@ -173,10 +155,6 @@ def audit_session(
if role == "assistant":
usage = entry.get("usage") or {}
if "cache_creation" not in usage or "cache_read" not in usage:
- # Pre-#15 transcript missing cache fields. Token totals
- # still meaningful (input/output present), but the cost
- # estimate is a lower bound — cache writes/reads cost
- # real money on Anthropic.
cost_is_lower_bound = True
pre_15_turns += 1
input_t = int(usage.get("input", 0) or 0)
@@ -222,9 +200,7 @@ def audit_session(
name = tr.get("name", "?")
m = _OFFLOAD_RE.match(content)
if m:
- attachment_refs[m.group(1)] = (
- attachment_refs.get(m.group(1), 0) + 1
- )
+ attachment_refs[m.group(1)] = attachment_refs.get(m.group(1), 0) + 1
continue
inline_bloat.append(
BloatRow(
@@ -238,22 +214,14 @@ def audit_session(
inline_bloat.sort(key=lambda r: r.char_count, reverse=True)
inline_bloat = inline_bloat[:top_bloat]
- # Attachments: list every file in attachments/ and tag with the
- # ref count from the tool-result scan. Files with ref_count == 0
- # are orphans (tool ran, but the attachment is no longer
- # referenced — usually because the turn was rolled back).
attachments: list[AttachmentRow] = []
orphans: list[str] = []
if attach_dir.exists():
for f in sorted(attach_dir.iterdir()):
if not f.is_file():
continue
- # The offload prefix uses the path as written by the agent.
- # Match by suffix `attachments/<name>` so a relative or
- # absolute path both hit. Mirrors `Session.find_orphan_attachments`.
- # The `attachments/` segment anchors the match so a tool
- # result that happens to mention a bare filename can't
- # falsely register as a reference.
+ # Match suffix "attachments/<name>" so relative and absolute
+ # offload paths both hit; bare-filename mentions can't.
ref_count = 0
for ref_path, count in attachment_refs.items():
if ref_path.endswith(f"attachments/{f.name}"):
@@ -267,9 +235,6 @@ def audit_session(
if ref_count == 0:
orphans.append(f.name)
- # Aggregate cost = sum of per-turn costs (correct across mixed
- # models). Falls back to summing-then-pricing only when no turn
- # had a priceable model.
if any_cost_priced:
total_cost_usd: float | None = per_turn_costs_sum
else:
@@ -281,10 +246,8 @@ def audit_session(
totals["cache_read"],
)
- # Header model: prefer the most recent turn's recorded model (the
- # session's "current" identity) so a session whose only
- # caller-supplied model was a fallback still surfaces what actually
- # ran. Drop back to the function arg if no turn recorded one.
+ # Prefer the most recent turn's recorded model so the header
+ # reflects what actually ran, not the caller's fallback arg.
header_model = recorded_models[-1] if recorded_models else model
return AuditReport(
diff --git a/pyagent/sessions_audit_render.py b/pyagent/sessions_audit_render.py
index ffcf6be..07acec6 100644
--- a/pyagent/sessions_audit_render.py
+++ b/pyagent/sessions_audit_render.py
@@ -9,7 +9,7 @@
import json
from dataclasses import asdict
-from typing import Iterable
+from collections.abc import Iterable
from pyagent.sessions_audit import AuditReport, _total_tokens_summary
@@ -55,17 +55,11 @@ def render_text(
sec = set(sections) if sections else set(ALL_SECTIONS)
lines: list[str] = []
- # Always-shown orientation header.
lines.append(f"session: {report.session_id}")
lines.append(f"model: {report.model or '(none)'}")
lines.append(f"turns: {report.turn_count}")
if "cost" in sec:
- # On Anthropic the four counts are disjoint and the displayed
- # total bundles all four. On OpenAI / Gemini the providers'
- # `prompt_tokens` / `prompt_token_count` already includes their
- # cached count; bundling cache_read on top would double-count.
- # `_total_tokens_summary` applies that gate.
tokens = report.total_tokens
total_all = _total_tokens_summary(report.model, tokens)
lines.append(
diff --git a/pyagent/sessions_cli.py b/pyagent/sessions_cli.py
index ef3977c..63699f8 100644
--- a/pyagent/sessions_cli.py
+++ b/pyagent/sessions_cli.py
@@ -24,12 +24,6 @@
render_text,
)
-
-# Used when --model is unset and no `default_model` is in config. Sonnet
-# is the broadly-available middle tier; the audit only uses this for
-# cost estimation, so a wrong default produces a wrong $ figure but
-# still-correct token totals. Centralized so future model bumps touch
-# one site.
_DEFAULT_AUDIT_MODEL = "anthropic/claude-sonnet-4-6"
@@ -70,9 +64,7 @@ def _info(d: Path) -> dict[str, object]:
if conv.exists():
with conv.open() as f:
turns = sum(1 for line in f if line.strip())
- total_size = sum(
- f.stat().st_size for f in d.rglob("*") if f.is_file()
- )
+ total_size = sum(f.stat().st_size for f in d.rglob("*") if f.is_file())
return {
"id": d.name,
"mtime": d.stat().st_mtime,
@@ -145,9 +137,7 @@ def delete_cmd(session_id: str | None, all_: bool, dry_run: bool) -> None:
if all_:
if session_id:
- raise click.UsageError(
- "pass either <session_id> or --all, not both."
- )
+ raise click.UsageError("pass either <session_id> or --all, not both.")
dirs = _session_dirs(root)
if not dirs:
click.echo(f"no sessions in {root}.")
@@ -198,9 +188,7 @@ def prune_cmd(
"""Bulk-delete sessions matching one selector. Dry-run by default."""
selectors = [older_than is not None, keep is not None, all_]
if sum(selectors) != 1:
- raise click.UsageError(
- "provide exactly one of --older-than, --keep, --all."
- )
+ raise click.UsageError("provide exactly one of --older-than, --keep, --all.")
root = _root()
dirs = _session_dirs(root)
@@ -250,9 +238,7 @@ def prune_cmd(
),
)
@click.option("--cost-only", "-c", is_flag=True, help="Show header only.")
-@click.option(
- "--turns-only", "-t", is_flag=True, help="Show per-turn table only."
-)
+@click.option("--turns-only", "-t", is_flag=True, help="Show per-turn table only.")
@click.option(
"--attachments-only",
"-a",
@@ -293,9 +279,6 @@ def audit_cmd(
if not target.exists():
raise click.ClickException(f"no session {session_id!r} in {root}.")
- # Resolve which sections the user wants. Default = all four. Any
- # `--*-only` flag narrows to that one section. Multiple `-only`
- # flags compose (so `-c -a` shows cost + attachments).
sections: set[str]
only_flags = {
"cost": cost_only,
@@ -308,7 +291,6 @@ def audit_cmd(
else:
sections = set(ALL_SECTIONS)
- # Resolve model: --model > config.default_model > sonnet fallback.
if model:
resolved_model = model
else:
diff --git a/pyagent/skills/__init__.py b/pyagent/skills/__init__.py
index bad154e..75008d6 100644
--- a/pyagent/skills/__init__.py
+++ b/pyagent/skills/__init__.py
@@ -49,7 +49,7 @@ class Skill:
name: str
description: str
body: str
- source: Path # absolute path to SKILL.md
+ source: Path
def _parse_frontmatter(text: str) -> tuple[dict[str, str], str]:
diff --git a/pyagent/skills/aviation-weather/scripts/cli.py b/pyagent/skills/aviation-weather/scripts/cli.py
index 11a953a..2335b71 100644
--- a/pyagent/skills/aviation-weather/scripts/cli.py
+++ b/pyagent/skills/aviation-weather/scripts/cli.py
@@ -77,8 +77,17 @@ def cmd_station_info(args: argparse.Namespace) -> str:
return s + "\n"
keep = {
k: s.get(k)
- for k in ("icaoId", "iataId", "site", "lat", "lon", "elev", "state",
- "country", "siteType")
+ for k in (
+ "icaoId",
+ "iataId",
+ "site",
+ "lat",
+ "lon",
+ "elev",
+ "state",
+ "country",
+ "siteType",
+ )
}
return json.dumps(keep, indent=2) + "\n"
@@ -170,16 +179,13 @@ def cmd_brief(args: argparse.Namespace) -> str:
pirep_radius = max(args.radius_nm * 4, 200)
sections: dict[str, Any] = {
"station": {
- k: s.get(k)
- for k in ("icaoId", "site", "lat", "lon", "elev", "siteType")
+ k: s.get(k) for k in ("icaoId", "site", "lat", "lon", "elev", "siteType")
},
"bbox": bbox,
"radius_nm": args.radius_nm,
}
- _, _, metars = _get(
- f"{_BASE}/metar?bbox={bbox}&format=json&hours={args.hours}"
- )
+ _, _, metars = _get(f"{_BASE}/metar?bbox={bbox}&format=json&hours={args.hours}")
sections["metars"] = metars if isinstance(metars, list) else []
_, _, tafs = _get(f"{_BASE}/taf?bbox={bbox}&format=json")
diff --git a/pyagent/skills/faa-registry/scripts/cli.py b/pyagent/skills/faa-registry/scripts/cli.py
index 04f2c4c..843a41c 100644
--- a/pyagent/skills/faa-registry/scripts/cli.py
+++ b/pyagent/skills/faa-registry/scripts/cli.py
@@ -116,7 +116,7 @@ def _format_tables(html: str) -> str:
elif len(cells) == 2:
out.append(f"- {cells[0]}: {cells[1]}")
elif len(cells) % 2 == 0:
- pairs = zip(cells[0::2], cells[1::2])
+ pairs = zip(cells[0::2], cells[1::2], strict=False)
for label, value in pairs:
out.append(f"- {label}: {value}")
else:
diff --git a/pyagent/skills/flight-tracker/scripts/cli.py b/pyagent/skills/flight-tracker/scripts/cli.py
index 0707a29..e54ee8f 100644
--- a/pyagent/skills/flight-tracker/scripts/cli.py
+++ b/pyagent/skills/flight-tracker/scripts/cli.py
@@ -85,10 +85,23 @@ def _get(path: str, params: dict[str, Any]) -> tuple[int, Any]:
_STATE_FIELDS = [
- "icao24", "callsign", "origin_country", "time_position", "last_contact",
- "longitude", "latitude", "baro_altitude", "on_ground", "velocity",
- "true_track", "vertical_rate", "sensors", "geo_altitude", "squawk",
- "spi", "position_source",
+ "icao24",
+ "callsign",
+ "origin_country",
+ "time_position",
+ "last_contact",
+ "longitude",
+ "latitude",
+ "baro_altitude",
+ "on_ground",
+ "velocity",
+ "true_track",
+ "vertical_rate",
+ "sensors",
+ "geo_altitude",
+ "squawk",
+ "spi",
+ "position_source",
]
@@ -97,7 +110,7 @@ def _decode_states(states: list[list[Any]] | None) -> list[dict[str, Any]]:
return []
out: list[dict[str, Any]] = []
for s in states:
- rec = {k: v for k, v in zip(_STATE_FIELDS, s)}
+ rec = dict(zip(_STATE_FIELDS, s, strict=False))
if isinstance(rec.get("callsign"), str):
rec["callsign"] = rec["callsign"].strip() or None
out.append(rec)
@@ -138,9 +151,7 @@ def _resolve_to_latlon(arg: str) -> tuple[float, float] | str:
return float(data[0]["lat"]), float(data[0]["lon"])
-def _states_in_bbox(
- lamin: float, lomin: float, lamax: float, lomax: float
-) -> str:
+def _states_in_bbox(lamin: float, lomin: float, lamax: float, lomax: float) -> str:
status, data = _get(
"/states/all",
{"lamin": lamin, "lomin": lomin, "lamax": lamax, "lomax": lomax},
@@ -152,9 +163,7 @@ def _states_in_bbox(
"Suggest the user set up credentials with `setup-credentials`.>\n"
)
return f"<states fetch failed: status={status}: {data}>\n"
- decoded = _decode_states(
- data.get("states") if isinstance(data, dict) else None
- )
+ decoded = _decode_states(data.get("states") if isinstance(data, dict) else None)
return json.dumps({"count": len(decoded), "states": decoded}, indent=2) + "\n"
diff --git a/pyagent/subagent.py b/pyagent/subagent.py
index cf08e5a..f49801d 100644
--- a/pyagent/subagent.py
+++ b/pyagent/subagent.py
@@ -33,7 +33,8 @@
from dataclasses import dataclass
from multiprocessing.connection import Connection
from multiprocessing.context import SpawnProcess
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
+from collections.abc import Callable
from pyagent import config as config_mod
from pyagent import permissions
@@ -59,13 +60,6 @@ class SubagentEntry:
depth: int
status: str = "idle" # idle | running | done | error
last_text: str = ""
- # Dispatch mode for the most-recent in-flight call to this
- # subagent. None when no call is in flight; "sync" while a
- # call_subagent is blocking on the reply queue; "async" while a
- # call_subagent_async has fired and not yet replied. The IO
- # thread reads this when a turn_complete arrives to decide
- # whether to land the reply on the per-sid reply queue (sync)
- # or on the parent Agent's pending_async_replies inbox (async).
mode: str | None = None
@@ -73,7 +67,7 @@ def _build_subagent_config(
name: str,
system_prompt: str,
base_config: dict[str, Any],
- parent_session: "Session",
+ parent_session: Session,
parent_depth: int,
model_override: str = "",
role: roles_mod.Role | None = None,
@@ -94,16 +88,14 @@ def _build_subagent_config(
cfg["role_body"] = role.system_prompt
cfg["role_tools"] = list(role.tools) if role.tools is not None else None
cfg["role_meta_tools"] = role.meta_tools
- # Inherit current approved paths so the user isn't re-prompted for
- # paths they already accepted in the parent's process.
cfg["approved_paths"] = [str(p) for p in permissions.approved_paths()]
return sid, cfg
def make_spawn_subagent(
- state: "_ChildState",
- agent: "Agent",
- parent_session: "Session",
+ state: _ChildState,
+ agent: Agent,
+ parent_session: Session,
base_config: dict[str, Any],
) -> Callable[..., str]:
"""Build the spawn_subagent tool, closing over the parent's state."""
@@ -111,9 +103,7 @@ def make_spawn_subagent(
max_depth = cfg["subagents"]["max_depth"]
max_fanout = cfg["subagents"]["max_fanout"]
- def spawn_subagent(
- name: str, system_prompt: str, model: str = ""
- ) -> str:
+ def spawn_subagent(name: str, system_prompt: str, model: str = "") -> str:
"""Spawn a subagent in its own subprocess.
The subagent inherits the universal SOUL/TOOLS/PRIMER base, the
@@ -175,8 +165,7 @@ def spawn_subagent(
ctx = multiprocessing.get_context("spawn")
parent_end, child_end = ctx.Pipe(duplex=True)
- # Late import to avoid an agent_proc <-> subagent cycle at
- # module-import time.
+ # late import to avoid agent_proc <-> subagent import cycle
from pyagent import agent_proc
proc = ctx.Process(
@@ -200,9 +189,6 @@ def spawn_subagent(
)
agent._subagents[sid] = entry
- # Block on the subagent's `ready` event (or an `agent_error`
- # if bootstrap failed). The IO thread routes both to the
- # subagent's reply queue.
try:
first = reply_queue.get(timeout=30)
except queue.Empty:
@@ -218,10 +204,7 @@ def spawn_subagent(
agent._subagents.pop(sid, None)
state.unregister_subagent_pipe(sid)
proc.join(timeout=2)
- return (
- f"<spawn failed: {first.get('kind')}: "
- f"{first.get('message')}>"
- )
+ return f"<spawn failed: {first.get('kind')}: " f"{first.get('message')}>"
if first.get("type") != "ready":
agent._subagents.pop(sid, None)
state.unregister_subagent_pipe(sid)
@@ -242,8 +225,8 @@ def spawn_subagent(
def make_call_subagent(
- state: "_ChildState",
- agent: "Agent",
+ state: _ChildState,
+ agent: Agent,
) -> Callable[..., str]:
"""Build the call_subagent tool."""
@@ -274,7 +257,6 @@ def call_subagent(id: str, message: str) -> str:
if not entry.process.is_alive():
return f"<subagent {id} is no longer running>"
- # Defensive drain in case prior turns left anything behind.
while not entry.reply_queue.empty():
try:
entry.reply_queue.get_nowait()
@@ -295,9 +277,6 @@ def call_subagent(id: str, message: str) -> str:
entry.mode = None
return f"<send failed to subagent {id}: {e}>"
- # No timeout here — subagents can legitimately take a long
- # time. Cancel from the CLI propagates down through the IO
- # thread's cancel pathway.
result = entry.reply_queue.get()
entry.status = "idle"
entry.mode = None
@@ -309,8 +288,7 @@ def call_subagent(id: str, message: str) -> str:
if kind == "agent_error":
entry.status = "error"
return (
- f"<subagent error: {result.get('kind')}: "
- f"{result.get('message')}>"
+ f"<subagent error: {result.get('kind')}: " f"{result.get('message')}>"
)
return f"<unexpected reply kind {kind!r}>"
@@ -318,8 +296,8 @@ def call_subagent(id: str, message: str) -> str:
def make_call_subagent_async(
- state: "_ChildState",
- agent: "Agent",
+ state: _ChildState,
+ agent: Agent,
) -> Callable[..., str]:
"""Build the call_subagent_async tool.
@@ -386,8 +364,8 @@ def call_subagent_async(id: str, message: str) -> str:
def make_wait_for_subagents(
- state: "_ChildState",
- agent: "Agent",
+ state: _ChildState,
+ agent: Agent,
) -> Callable[..., str]:
"""Build the wait_for_subagents tool.
@@ -430,8 +408,8 @@ def wait_for_subagents(timeout: int = 300) -> str:
def make_ask_parent(
- state: "_ChildState",
- agent: "Agent",
+ state: _ChildState,
+ agent: Agent,
) -> Callable[..., str]:
"""Build the `ask_parent` tool — only registered on subagents.
@@ -486,8 +464,6 @@ def ask_parent(question: str) -> str:
req_id = f"req-{uuid.uuid4().hex[:8]}"
rq: queue.Queue = queue.Queue(maxsize=1)
with state._ask_lock:
- # Refuse stacked asks — keep the model's reasoning
- # straightforward (one question at a time per subagent).
if state._pending_ask_replies:
return (
"<refused: another ask_parent is already in "
@@ -496,9 +472,7 @@ def ask_parent(question: str) -> str:
state._pending_ask_replies[req_id] = rq
try:
- state.send(
- "subagent_ask", request_id=req_id, question=question
- )
+ state.send("subagent_ask", request_id=req_id, question=question)
except Exception as e:
with state._ask_lock:
state._pending_ask_replies.pop(req_id, None)
@@ -520,8 +494,8 @@ def ask_parent(question: str) -> str:
def make_notify_parent(
- state: "_ChildState",
- agent: "Agent",
+ state: _ChildState,
+ agent: Agent,
) -> Callable[..., str]:
"""Build the `notify_parent` tool — only registered on subagents.
@@ -571,9 +545,7 @@ def notify_parent(text: str, severity: str = "info") -> str:
valid = ", ".join(repr(s) for s in _NOTIFY_VALID_SEVERITIES)
return f"<refused: severity {severity!r} not in {{{valid}}}>"
try:
- state.send(
- "subagent_note", severity=severity, text=text
- )
+ state.send("subagent_note", severity=severity, text=text)
except Exception as e:
return f"<send failed: {type(e).__name__}: {e}>"
return f"note sent ({severity})"
@@ -582,8 +554,8 @@ def notify_parent(text: str, severity: str = "info") -> str:
def make_reply_to_subagent(
- state: "_ChildState",
- agent: "Agent",
+ state: _ChildState,
+ agent: Agent,
) -> Callable[..., str]:
"""Build the `reply_to_subagent` tool — registered on agents
that can spawn subagents (`allow_meta=True`).
@@ -628,8 +600,7 @@ def reply_to_subagent(request_id: str, answer: str) -> str:
entry: SubagentEntry | None = agent._subagents.get(sid)
if entry is None or not entry.process.is_alive():
return (
- f"<subagent {sid} for request {request_id!r} is "
- f"no longer running>"
+ f"<subagent {sid} for request {request_id!r} is " f"no longer running>"
)
try:
protocol.send(
@@ -646,8 +617,8 @@ def reply_to_subagent(request_id: str, answer: str) -> str:
def make_tell_subagent(
- state: "_ChildState",
- agent: "Agent",
+ state: _ChildState,
+ agent: Agent,
) -> Callable[..., str]:
"""Build the `tell_subagent` tool — registered on agents that
can spawn subagents (`allow_meta=True`).
@@ -705,7 +676,7 @@ def tell_subagent(sid: str, text: str) -> str:
def _collect_subagent_notes(
- agent: "Agent", sid: str, cursor: int | None
+ agent: Agent, sid: str, cursor: int | None
) -> dict[str, Any]:
"""Return a structured record of one subagent's notes.
@@ -756,8 +727,6 @@ def _collect_subagent_notes(
else:
cur_label = cursor
visible = [e for e in ring if e[0] > cursor]
- # Missing entries: seqs in (cursor, earliest_seq) were
- # dropped from the ring before this peek caught up.
missing = max(0, earliest_seq - 1 - cursor)
return {
@@ -797,15 +766,13 @@ def _format_peek_section(record: dict[str, Any]) -> str:
return "\n".join(lines)
for e in entries:
ts_label = f"t+{int(e['ts'])}s"
- lines.append(
- f" - ({e['severity']}, {ts_label}) {e['text']}"
- )
+ lines.append(f" - ({e['severity']}, {ts_label}) {e['text']}")
return "\n".join(lines)
def make_peek_subagent(
- state: "_ChildState",
- agent: "Agent",
+ state: _ChildState,
+ agent: Agent,
) -> Callable[..., str]:
"""Build the `peek_subagent` tool — registered on agents that
can spawn subagents (`allow_meta=True`).
@@ -816,9 +783,7 @@ def make_peek_subagent(
invalidate the next planned tool call. Issue #65.
"""
- def peek_subagent(
- sid: str | None = None, since: str | None = None
- ) -> str:
+ def peek_subagent(sid: str | None = None, since: str | None = None) -> str:
"""Do not call this reflexively.
Default expectation: subagent notes surface as user-role
@@ -867,9 +832,7 @@ def peek_subagent(
f"or JSON object, got {type(obj).__name__}>"
)
try:
- parsed_dict = {
- str(k): int(v) for k, v in obj.items()
- }
+ parsed_dict = {str(k): int(v) for k, v in obj.items()}
except (ValueError, TypeError) as e:
return (
f"<refused: invalid since: cursor values "
@@ -914,17 +877,14 @@ def peek_subagent(
record = _collect_subagent_notes(agent, s, cur)
sections.append(_format_peek_section(record))
next_cursors[s] = record["next_cursor"]
- return (
- "\n\n".join(sections)
- + f"\n\nnext_cursor: {json.dumps(next_cursors)}"
- )
+ return "\n\n".join(sections) + f"\n\nnext_cursor: {json.dumps(next_cursors)}"
return peek_subagent
def make_terminate_subagent(
- state: "_ChildState",
- agent: "Agent",
+ state: _ChildState,
+ agent: Agent,
) -> Callable[..., str]:
"""Build the terminate_subagent tool."""
@@ -946,9 +906,6 @@ def terminate_subagent(id: str) -> str:
return f"<unknown subagent id: {id!r}>"
state.unregister_subagent_pipe(id)
- # Drop the per-sid notification ring (issue #65). After
- # terminate, the sid is no longer peekable — late peeks
- # of dead sids should return the unknown-subagent marker.
agent._clear_subagent_notes(id)
if entry.process.is_alive():
@@ -959,15 +916,14 @@ def terminate_subagent(id: str) -> str:
entry.process.join(timeout=5)
if entry.process.is_alive():
try:
- entry.process.terminate() # SIGTERM
+ entry.process.terminate()
except Exception:
pass
entry.process.join(timeout=2)
if entry.process.is_alive():
- # Last resort. terminate() should be enough, but a
- # subagent stuck in C extension code might not heed it.
try:
import os
+
os.kill(entry.process.pid, signal.SIGKILL)
except Exception:
pass
diff --git a/pyagent/tool_schema.py b/pyagent/tool_schema.py
index 4a23c17..3535a2a 100644
--- a/pyagent/tool_schema.py
+++ b/pyagent/tool_schema.py
@@ -29,7 +29,8 @@
import inspect
import types
-from typing import Any, Callable, Union, get_args, get_origin, get_type_hints
+from typing import Any, Union, get_args, get_origin, get_type_hints
+from collections.abc import Callable
from docstring_parser import parse
@@ -80,9 +81,7 @@ def schema(name: str, fn: Callable[..., Any]) -> dict[str, Any]:
if doc.long_description:
description = f"{description}\n\n{doc.long_description}".strip()
if doc.returns and doc.returns.description:
- description = (
- f"{description}\n\nReturns: {doc.returns.description}".strip()
- )
+ description = f"{description}\n\nReturns: {doc.returns.description}".strip()
return {
"name": name,
diff --git a/pyagent/tools.py b/pyagent/tools.py
index 58d3e18..dcf1b2c 100644
--- a/pyagent/tools.py
+++ b/pyagent/tools.py
@@ -35,7 +35,6 @@
from pyagent import permissions
from pyagent.session import Attachment
-#: Prefix character that marks an errors-as-data tool result.
ERROR_MARKER_PREFIX = "<"
@@ -56,17 +55,10 @@ def is_error_result(content: str) -> bool:
s = content.lstrip()
return s.startswith(ERROR_MARKER_PREFIX)
-# Track in-flight execute() shell subprocesses so the cancel pathway
-# can kill them on Esc. Within a single agent process the tool loop
-# runs serially (so this list is usually 0 or 1), but a list keeps it
-# safe if anything ever runs an `execute` from a worker thread.
+
_ACTIVE_EXEC_PROCS: list[subprocess.Popen] = []
_ACTIVE_EXEC_LOCK = threading.Lock()
-# Per-stream rolling cap for background-process output. When either
-# stdout or stderr crosses this size, the oldest 256KB are dropped and
-# a `...truncated NN bytes...` notice rides the next read so the agent
-# knows the tail is incomplete.
_BG_BUF_CAP = 1024 * 1024
_BG_BUF_DROP = 256 * 1024
@@ -97,7 +89,7 @@ class _BackgroundProc:
lock: threading.Lock = field(default_factory=threading.Lock)
output_buf: bytearray = field(default_factory=bytearray)
dropped: int = 0
- last_source: str = "" # "stdout" | "stderr" | "" (initial)
+ last_source: str = ""
last_write: float = 0.0
threads: list[threading.Thread] = field(default_factory=list)
@@ -128,7 +120,6 @@ def kill_active() -> int:
os.killpg(proc.pid, signal.SIGKILL)
killed += 1
except ProcessLookupError:
- # Already exited between the lock and the kill.
pass
with _ACTIVE_BG_LOCK:
bg_entries = list(_ACTIVE_BG_PROCS.values())
@@ -181,16 +172,7 @@ def _denied(path: str) -> str:
return f"<permission denied (outside workspace): {path}>"
-# Memory tools (create_memory / read_memory / update_memory /
-# delete_memory / write_user / recall_memory) live in the bundled
-# memory plugin (pyagent/plugins/memory/). Disabling the plugin
-# removes them entirely — clean replacement surface for alternative
-# memory backends.
-
-
-def read_file(
- path: str, start: int = 1, end: int | None = None
-) -> "str | Attachment":
+def read_file(path: str, start: int = 1, end: int | None = None) -> "str | Attachment":
"""Read a file and return its contents.
For text files, returns the requested lines as a string. For binary
@@ -212,10 +194,6 @@ def read_file(
failures (missing path, permission denied, etc.) come back as a
leading `<...>` marker string.
"""
- # Models occasionally emit numeric tool args as strings ("50" instead
- # of 50) even when the JSON schema declares int. Coerce defensively
- # so the tool returns an actionable error instead of crashing the
- # turn — surfaced live during the pyagent_self_audit bench run.
try:
start = int(start)
except (TypeError, ValueError):
@@ -386,7 +364,7 @@ def edit_file(
else:
idx = text.find(old_string)
line_no = text[:idx].count("\n") + 1
- new_text = text[:idx] + new_string + text[idx + len(old_string):]
+ new_text = text[:idx] + new_string + text[idx + len(old_string) :]
success = f"Edited {path}: replaced 1 occurrence at line {line_no}"
try:
@@ -474,7 +452,6 @@ def grep(
f"<error: before/after/context must be non-negative, got "
f"before={before_i}, after={after_i}, context={context_i}>"
]
- # Explicit before/after override the matching side of context.
eff_before = before_i if before_i > 0 else context_i
eff_after = after_i if after_i > 0 else context_i
@@ -495,27 +472,21 @@ def grep(
except (UnicodeDecodeError, PermissionError):
continue
lines = text.splitlines()
- match_idxs = [
- i for i, line in enumerate(lines) if regex.search(line)
- ]
+ match_idxs = [i for i, line in enumerate(lines) if regex.search(line)]
if not match_idxs:
continue
if not use_context:
for i in match_idxs:
results.append(f"{f}:{i + 1}:{lines[i]}")
continue
- # Build collapsed groups: a new group starts when the next
- # match's leading context window doesn't touch the previous
- # group's trailing context window.
match_set = set(match_idxs)
- groups: list[tuple[int, int]] = [] # inclusive (start, end) line idx
+ groups: list[tuple[int, int]] = []
cur_start = max(0, match_idxs[0] - eff_before)
cur_end = min(len(lines) - 1, match_idxs[0] + eff_after)
for m in match_idxs[1:]:
m_start = max(0, m - eff_before)
m_end = min(len(lines) - 1, m + eff_after)
if m_start <= cur_end + 1:
- # Windows touch or overlap — extend.
if m_end > cur_end:
cur_end = m_end
else:
@@ -532,11 +503,6 @@ def grep(
return results
-# Default exclusion globs for `glob`. Mirrors the
-# shutil.ignore_patterns set bench_cli uses when seeding workspaces
-# (see pyagent/bench_cli.py) so users see the same rules across pyagent.
-# We deliberately don't parse `.gitignore` — that's scope creep; ad-hoc
-# overrides should pass an explicit `root` and a tighter pattern.
_GLOB_DEFAULT_EXCLUDES: tuple[str, ...] = (
".git",
".venv",
@@ -608,7 +574,9 @@ def glob(
elif isinstance(pattern, list):
patterns = [str(p) for p in pattern]
else:
- return [f"<error: pattern must be str or list[str], got {type(pattern).__name__}>"]
+ return [
+ f"<error: pattern must be str or list[str], got {type(pattern).__name__}>"
+ ]
if not patterns:
return ["<error: pattern list is empty>"]
@@ -630,7 +598,6 @@ def glob(
try:
rel = hit.relative_to(root_path)
except ValueError:
- # Pattern escaped the root via "..", skip.
continue
if _is_excluded(rel.parts):
continue
@@ -642,17 +609,11 @@ def glob(
total = len(sorted_rel)
if total > limit:
capped = sorted_rel[:limit]
- capped.append(
- f"<truncated: {total} total matches; tighten the pattern>"
- )
+ capped.append(f"<truncated: {total} total matches; tighten the pattern>")
return capped
return sorted_rel
-# Patterns that should never run unattended. This is a speed bump
-# against accidents, not a sandbox — a determined model can dodge any
-# regex with variable expansion, escapes, or base64. Real safety lives
-# in the human-in-the-loop and OS-level isolation.
_DANGEROUS_PATTERNS: list[tuple[str, str]] = [
(r"--no-preserve-root", "rm bypassing root protection"),
(
@@ -732,10 +693,6 @@ def execute(command: str) -> str:
f"<refused: matches dangerous pattern ({blocked}); "
f"ask the human to run it manually if intended>"
)
- # Run the shell in its own process group so a timeout takes the whole
- # tree (including grandchildren) rather than orphaning them. stdin is
- # closed so subprocesses can't accidentally consume the parent's
- # raw-mode stdin or hang waiting for input.
proc = subprocess.Popen(
command,
shell=True,
@@ -766,23 +723,7 @@ def execute(command: str) -> str:
pass
if stdout and not stdout.endswith("\n"):
stdout += "\n"
- return (
- f"exit_code: {returncode}\n"
- f"stdout:\n{stdout}"
- f"stderr:\n{stderr}"
- )
-
-
-# ---------------------------------------------------------------------------
-# Background shell processes — run_background / read_output / wait_for /
-# kill_process. Lifecycle:
-# run_background spawns + registers a handle, returns the handle id.
-# read_output decodes the captured bytes since an offset.
-# wait_for blocks (with timeout) until exit / output match /
-# silence settles.
-# kill_process SIGKILLs the group and removes the handle.
-# kill_active() (above) flushes BOTH foreground and background sets so
-# the cancel pathway leaves a clean slate.
+ return f"exit_code: {returncode}\n" f"stdout:\n{stdout}" f"stderr:\n{stderr}"
def _bg_handle() -> str:
@@ -806,38 +747,24 @@ def _bg_reader(bg: _BackgroundProc, stream, which: str) -> None:
"""
try:
while True:
- # `read1` returns whatever is currently buffered up to the
- # cap — `read(4096)` would block until 4096 bytes (or EOF),
- # which interacts badly with line-buffered tools that emit
- # short bursts and then sleep. Tail-follow needs the
- # bytes-out-now semantics.
chunk = stream.read1(4096)
if not chunk:
break
with bg.lock:
- # Insert a transition marker only when the source
- # actually changes; the initial state (last_source="")
- # treats stdout as the implicit default — no leading
- # `[stdout]` marker on processes that never use stderr.
if which != bg.last_source and (
bg.last_source != "" or which != "stdout"
):
if bg.output_buf and not bg.output_buf.endswith(b"\n"):
- bg.output_buf.append(0x0A) # newline
+ bg.output_buf.append(0x0A)
bg.output_buf.extend(f"[{which}]\n".encode())
bg.last_source = which
bg.output_buf.extend(chunk)
if len(bg.output_buf) > _BG_BUF_CAP:
- overflow = len(bg.output_buf) - (
- _BG_BUF_CAP - _BG_BUF_DROP
- )
+ overflow = len(bg.output_buf) - (_BG_BUF_CAP - _BG_BUF_DROP)
del bg.output_buf[:overflow]
bg.dropped += overflow
bg.last_write = time.monotonic()
except (ValueError, OSError):
- # Stream closed underneath us (proc died, fd reaped). The
- # main reader exits — wait_for / read_output handle the
- # post-mortem state via proc.poll().
pass
finally:
try:
@@ -1004,9 +931,7 @@ def read_output(handle: str, *, since: int = 0, max_chars: int = 4000) -> str:
return bg
with bg.lock:
- text, next_since = _decode_with_drop(
- bg.output_buf, since, bg.dropped
- )
+ text, next_since = _decode_with_drop(bg.output_buf, since, bg.dropped)
rc = bg.proc.poll()
status = "running" if rc is None else f"exited (rc={rc})"
@@ -1094,12 +1019,10 @@ def wait_for(
f"{timeout_s}s; tail:\n{tail}>"
)
tail = _tail(_combined_text(bg))
- return (
- f"exited {bg.handle} ({bg.name}) rc={rc}\ntail:\n{tail}"
- )
+ return f"exited {bg.handle} ({bg.name}) rc={rc}\ntail:\n{tail}"
if until.startswith("output_contains:"):
- needle = until[len("output_contains:"):]
+ needle = until[len("output_contains:") :]
if not needle:
return "<error: output_contains needs a non-empty substring>"
while time.monotonic() < deadline:
@@ -1110,8 +1033,6 @@ def wait_for(
f"{needle!r}\ntail:\n{tail}"
)
if bg.proc.poll() is not None:
- # Process exited before we matched. Check one more time
- # in case the final bytes landed under the lock.
if needle in _combined_text(bg):
tail = _tail(_combined_text(bg))
return (
@@ -1132,7 +1053,7 @@ def wait_for(
)
if until.startswith("output_matches:"):
- pattern = until[len("output_matches:"):]
+ pattern = until[len("output_matches:") :]
if not pattern:
return "<error: output_matches needs a non-empty regex>"
try:
@@ -1172,7 +1093,7 @@ def wait_for(
)
if until.startswith("silence:"):
- spec = until[len("silence:"):]
+ spec = until[len("silence:") :]
if spec.endswith("s"):
spec = spec[:-1]
try:
@@ -1192,8 +1113,6 @@ def wait_for(
f"{quiet_s}s without new output\ntail:\n{tail}"
)
if bg.proc.poll() is not None:
- # Exited; treat the remaining quiet window as instantly
- # satisfied — no more output is coming.
tail = _tail(_combined_text(bg))
return (
f"settled {bg.handle} ({bg.name}) — process exited "
@@ -1235,7 +1154,6 @@ def kill_process(handle: str) -> str:
try:
os.killpg(bg.proc.pid, signal.SIGKILL)
except ProcessLookupError:
- # Already exited; fall through and clean up.
pass
try:
rc = bg.proc.wait(timeout=2.0)
@@ -1244,9 +1162,7 @@ def kill_process(handle: str) -> str:
rc_str = "unknown (wait timed out)"
with _ACTIVE_BG_LOCK:
_ACTIVE_BG_PROCS.pop(bg.handle, None)
- return (
- f"killed {bg.handle} ({bg.name}) rc={rc_str}"
- )
+ return f"killed {bg.handle} ({bg.name}) rc={rc_str}"
_FETCH_UA = (
@@ -1254,15 +1170,8 @@ def kill_process(handle: str) -> str:
"(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
)
-# Cap the inline markdown so a giant page can't blow the conversation.
-# Past this size we truncate the inline body and tell the agent to
-# `read_file` the saved raw HTML attachment for the full content (or
-# `html_select` if a researcher role wants a specific CSS slice).
_FETCH_INLINE_MD_CEILING = 8000
-# Soft import: when the html-tools plugin is enabled (the default),
-# fetch_url uses its conversion as a convenience. When the plugin is
-# disabled or its deps are missing, we fall back to raw-attachment-only.
try:
from pyagent.plugins.html_tools import extraction as _html_extraction
except ImportError:
@@ -1273,12 +1182,11 @@ def _detect_content_type(headers: dict, body: str) -> tuple[str, bool]:
"""Return (content_type, is_html). content_type is the mime portion
of the Content-Type header, lowercased; is_html is True for HTML
responses (used to decide whether markdown conversion applies)."""
- raw = (headers.get("Content-Type") or headers.get("content-type") or "")
+ raw = headers.get("Content-Type") or headers.get("content-type") or ""
ctype = raw.split(";", 1)[0].strip().lower()
if not ctype:
- # Cheap content sniff for hosts that don't set Content-Type.
head = body[:512].lstrip().lower()
- if head.startswith("<!doctype html") or head.startswith("<html"):
+ if head.startswith(("<!doctype html", "<html")):
ctype = "text/html"
elif head.startswith(("{", "[")):
ctype = "application/json"
@@ -1329,9 +1237,7 @@ def fetch_url(
→ `<request failed: ...>`.
"""
try:
- response = requests.get(
- url, headers={"User-Agent": _FETCH_UA}, timeout=30
- )
+ response = requests.get(url, headers={"User-Agent": _FETCH_UA}, timeout=30)
except requests.RequestException as e:
return f"<request failed: {e}>"
@@ -1341,13 +1247,12 @@ def fetch_url(
size = len(body)
header_lines = [
- f"Fetched {url} (status {response.status_code}, "
- f"{size} chars, {ctype}).",
+ f"Fetched {url} (status {response.status_code}, " f"{size} chars, {ctype}).",
]
if format == "void":
header_lines.append(
- "No content returned (format=\"void\"). Use `grep`, "
+ 'No content returned (format="void"). Use `grep`, '
"`read_file`, or `html_select` (researcher role) on the "
"saved path to interrogate."
)
@@ -1357,8 +1262,8 @@ def fetch_url(
if not is_html or _html_extraction is None:
if not is_html:
header_lines.append(
- f"Non-HTML response. Use `read_file` / `grep` on the "
- f"saved path to extract."
+ "Non-HTML response. Use `read_file` / `grep` on the "
+ "saved path to extract."
)
else:
header_lines.append(
@@ -1369,9 +1274,7 @@ def fetch_url(
return Attachment(content=body, preview=preview, suffix=suffix)
try:
- md = _html_extraction.html_to_markdown(
- body, main_content=main_content
- )
+ md = _html_extraction.html_to_markdown(body, main_content=main_content)
except Exception as e:
header_lines.append(
f"Markdown conversion failed ({type(e).__name__}: {e}). "
@@ -1399,5 +1302,3 @@ def fetch_url(
)
preview = "\n".join(header_lines) + "\n\n" + md_inline
return Attachment(content=body, preview=preview, suffix=suffix)
-
-
diff --git a/pyagent/venv.py b/pyagent/venv.py
index 9963b83..17c7c3e 100644
--- a/pyagent/venv.py
+++ b/pyagent/venv.py
@@ -93,12 +93,8 @@ def _create(target: Path) -> Path:
decides how to surface that (likely as a tool-result marker).
Returns the resolved path on success.
"""
- logger.info(
- "creating venv at %s using %s", target, sys.executable
- )
+ logger.info("creating venv at %s using %s", target, sys.executable)
try:
- # `--without-pip` would be faster but then we have to
- # bootstrap pip ourselves; default behavior installs pip.
subprocess.run(
[sys.executable, "-m", "venv", str(target)],
check=True,
@@ -112,9 +108,7 @@ def _create(target: Path) -> Path:
f"{(e.stderr or e.stdout or '').strip()[:500]}"
) from e
except subprocess.TimeoutExpired as e:
- raise RuntimeError(
- f"venv creation timed out after 120s at {target}"
- ) from e
+ raise RuntimeError(f"venv creation timed out after 120s at {target}") from e
if not is_venv(target):
raise RuntimeError(
diff --git a/pyproject.toml b/pyproject.toml
index 63de461..3b28fc7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,13 +1,24 @@
[build-system]
-requires = ["setuptools>=68"]
+requires = ["setuptools>=77"]
build-backend = "setuptools.build_meta"
[project]
name = "pyagent"
version = "0.1.0"
+description = "A Python LLM-agent framework with a plugin system."
+readme = "README.md"
requires-python = ">=3.11"
license = "MIT"
license-files = ["LICENSE"]
+authors = [{name = "Derek Wisong", email = "derekwisong@gmail.com"}]
+keywords = ["llm", "agent", "anthropic", "claude", "openai", "gemini", "ollama"]
+classifiers = [
+ "Development Status :: 3 - Alpha",
+ "Programming Language :: Python :: 3.11",
+ "Programming Language :: Python :: 3.12",
+ "Programming Language :: Python :: 3.13",
+ "Topic :: Software Development :: Libraries",
+]
dependencies = [
"anthropic>=0.40",
"beautifulsoup4>=4.12",
@@ -32,13 +43,73 @@ dependencies = [
"requests>=2.31",
"rich>=13",
"tree-sitter>=0.25",
- "tree-sitter-language-pack>=0.10",
+ # 1.x switched to a download-on-demand model (only ~8 languages
+ # bundled; rest fetch from the internet at first get_language()).
+ # That hangs offline / in restricted CI. Stay on 0.x until upstream
+ # offers an opt-out.
+ "tree-sitter-language-pack>=0.10,<1.0",
# Visible-width measurement for the status footer's three-zone
# layout — Braille spinner and middle-dot separators need accurate
# widths for the right-zone padding math.
"wcwidth>=0.2",
]
+[project.urls]
+Homepage = "https://github.com/derekwisong/pyagent"
+Repository = "https://github.com/derekwisong/pyagent"
+Issues = "https://github.com/derekwisong/pyagent/issues"
+
+[project.optional-dependencies]
+dev = [
+ "black>=24",
+ "ruff>=0.6",
+ "pre-commit>=3",
+ # Required by the py-dev-toolkit plugin's run_pytest tool, which
+ # one of the tests exercises. Not a runtime dep.
+ "pytest>=7",
+]
+
+[tool.black]
+line-length = 88
+target-version = ["py311", "py312", "py313"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py311"
+
+[tool.ruff.lint]
+select = [
+ "E", # pycodestyle errors
+ "F", # pyflakes
+ "W", # pycodestyle warnings
+ "B", # flake8-bugbear (real bugs / smells)
+ "C4", # flake8-comprehensions
+ "SIM", # flake8-simplify
+ "UP", # pyupgrade
+ "RET", # flake8-return
+ "PIE", # flake8-pie
+]
+ignore = [
+ "E501", # line length — black handles this
+ "B008", # function call in default arg — common Click/Typer pattern
+ "SIM105", # try/except/pass is often clearer than contextlib.suppress
+ "SIM108", # ternary not always clearer than if/else
+]
+
+[tool.ruff.lint.per-file-ignores]
+# Tests can be looser: unused imports/vars and lambda binds are common
+# in stub-heavy tests.
+"tests/*" = [
+ "F401", # unused-import
+ "F811", # redefined-while-unused
+ "F841", # unused-variable
+ "B007", # unused loop control var
+ "B904", # raise without `from` inside except
+ "E731", # lambda assignment
+ "E741", # ambiguous variable name
+ "SIM117", # nested with statements
+]
+
[project.scripts]
pyagent = "pyagent.cli:main"
pyagent-config = "pyagent.config_cli:main"
diff --git a/tests/smoke_agent_label.py b/tests/test_agent_label.py
similarity index 92%
rename from tests/smoke_agent_label.py
rename to tests/test_agent_label.py
index 359a8b5..dc48b3b 100644
--- a/tests/smoke_agent_label.py
+++ b/tests/test_agent_label.py
@@ -11,7 +11,7 @@
Run with:
- .venv/bin/python -m tests.smoke_agent_label
+ .venv/bin/python -m tests.test_agent_label
"""
from __future__ import annotations
@@ -32,9 +32,7 @@ def main() -> None:
# Subagent label survives the markup parser.
label = _agent_label("sleeper-519f719d")
buf = io.StringIO()
- Console(file=buf, force_terminal=False, color_system=None).print(
- f"{label}ready"
- )
+ Console(file=buf, force_terminal=False, color_system=None).print(f"{label}ready")
rendered = buf.getvalue().rstrip()
assert rendered == "[sleeper-519f719d] ready", repr(rendered)
print(f"✓ subagent label renders literally: {rendered!r}")
@@ -45,9 +43,7 @@ def main() -> None:
f"{label}[dim]· execute command=sleep 5[/dim]"
)
rendered = buf.getvalue().rstrip()
- assert rendered == "[sleeper-519f719d] · execute command=sleep 5", (
- repr(rendered)
- )
+ assert rendered == "[sleeper-519f719d] · execute command=sleep 5", repr(rendered)
print(f"✓ tool-call shape renders: {rendered!r}")
print("\nALL CHECKS PASSED")
diff --git a/tests/smoke_arg_scrubbing.py b/tests/test_arg_scrubbing.py
similarity index 96%
rename from tests/smoke_arg_scrubbing.py
rename to tests/test_arg_scrubbing.py
index 4d87c13..5e77b94 100644
--- a/tests/smoke_arg_scrubbing.py
+++ b/tests/test_arg_scrubbing.py
@@ -13,7 +13,7 @@
Run with:
- .venv/bin/python -m tests.smoke_arg_scrubbing
+ .venv/bin/python -m tests.test_arg_scrubbing
"""
from __future__ import annotations
@@ -63,9 +63,9 @@ def big_writer(path: str, content: str) -> str:
# The tool ran with the full content (proves we scrubbed
# AFTER, not before).
- assert captured["seen_content_len"] == str(len(big_content)), (
- f"tool saw wrong content length: {captured!r}"
- )
+ assert captured["seen_content_len"] == str(
+ len(big_content)
+ ), f"tool saw wrong content length: {captured!r}"
# Tool result reports what happened.
assert "Wrote 10000 bytes" in result, result
@@ -87,6 +87,7 @@ def big_writer(path: str, content: str) -> str:
)
finally:
import shutil
+
shutil.rmtree(tmp, ignore_errors=True)
diff --git a/tests/smoke_ask_parent.py b/tests/test_ask_parent.py
similarity index 91%
rename from tests/smoke_ask_parent.py
rename to tests/test_ask_parent.py
index 9395c92..6abd549 100644
--- a/tests/smoke_ask_parent.py
+++ b/tests/test_ask_parent.py
@@ -25,7 +25,7 @@
In-process — no real LLM, no subprocesses. Run with:
- .venv/bin/python -m tests.smoke_ask_parent
+ .venv/bin/python -m tests.test_ask_parent
"""
from __future__ import annotations
@@ -59,7 +59,11 @@ def is_alive(self) -> bool:
return self._alive
-def _make_subagent_state(tmp: Path) -> tuple[agent_proc._ChildState, "multiprocessing.connection.Connection", threading.Thread]:
+def _make_subagent_state(
+ tmp: Path,
+) -> tuple[
+ agent_proc._ChildState, multiprocessing.connection.Connection, threading.Thread
+]:
"""Build a `_ChildState` configured as a subagent, plus the
"upstream test end" of its pipe (the test's handle for what
the parent would see). Returns (state, upstream_test_end,
@@ -75,7 +79,7 @@ def _make_subagent_state(tmp: Path) -> tuple[agent_proc._ChildState, "multiproce
def main() -> None:
- tmp = Path(tempfile.mkdtemp(prefix="pyagent-ask-smoke-"))
+ tmp = Path(tempfile.mkdtemp(prefix="pyagent-ask-test-"))
os.chdir(tmp)
print(f"cwd: {tmp}")
@@ -110,11 +114,13 @@ def asker(question: str) -> None:
print(f"✓ ask emitted upstream: req_id={req_id}")
# Inject the parent's answer.
- upstream.send({
- "type": "parent_answer",
- "request_id": req_id,
- "answer": "go ahead",
- })
+ upstream.send(
+ {
+ "type": "parent_answer",
+ "request_id": req_id,
+ "answer": "go ahead",
+ }
+ )
t.join(timeout=3.0)
assert not t.is_alive(), "ask_parent did not return after answer"
assert result_holder["v"] == "go ahead", result_holder
@@ -156,11 +162,13 @@ def asker(question: str) -> None:
# answer and confirm the registry would clean up.
with state._ask_lock:
pending_req_id = next(iter(state._pending_ask_replies.keys()))
- upstream.send({
- "type": "parent_answer",
- "request_id": pending_req_id,
- "answer": "fast-resolve",
- })
+ upstream.send(
+ {
+ "type": "parent_answer",
+ "request_id": pending_req_id,
+ "answer": "fast-resolve",
+ }
+ )
t.join(timeout=2.0)
assert result_holder.get("v") == "fast-resolve", result_holder
print("✓ pending-ask cleanup after answer (skipping 300s timeout assertion)")
@@ -227,11 +235,13 @@ def asker(question: str) -> None:
try:
# 5. inbound subagent_ask is consumed and queued.
- fake_sub_end.send({
- "type": "subagent_ask",
- "request_id": "req-deadbeef",
- "question": "install requests==2.31.0",
- })
+ fake_sub_end.send(
+ {
+ "type": "subagent_ask",
+ "request_id": "req-deadbeef",
+ "question": "install requests==2.31.0",
+ }
+ )
# Wait for the parent IO thread to process.
deadline = time.monotonic() + 2.0
while time.monotonic() < deadline:
@@ -248,9 +258,9 @@ def asker(question: str) -> None:
assert "install requests==2.31.0" in msg, msg
# request_id -> sid recorded
with pstate._ask_lock:
- assert pstate._inbound_ask_sid == {"req-deadbeef": fake_sid}, (
- pstate._inbound_ask_sid
- )
+ assert pstate._inbound_ask_sid == {
+ "req-deadbeef": fake_sid
+ }, pstate._inbound_ask_sid
print(f"✓ parent queued ask: {msg!r}")
# The IO thread also forwards the ask upstream so the CLI
@@ -267,7 +277,9 @@ def asker(question: str) -> None:
print(f"✓ ask forwarded upstream with agent_id={fake_sid}")
# 6. reply_to_subagent sends parent_answer down the pipe.
- result = reply_tool("req-deadbeef", "go ahead, use --break-system-packages? no.")
+ result = reply_tool(
+ "req-deadbeef", "go ahead, use --break-system-packages? no."
+ )
assert "replied" in result and fake_sid in result, result
# The fake child's pipe end should now hold a parent_answer.
deadline = time.monotonic() + 2.0
diff --git a/tests/smoke_async_subagent.py b/tests/test_async_subagent.py
similarity index 93%
rename from tests/smoke_async_subagent.py
rename to tests/test_async_subagent.py
index a394ca5..e5b8cc7 100644
--- a/tests/smoke_async_subagent.py
+++ b/tests/test_async_subagent.py
@@ -16,7 +16,7 @@
In-process — no real LLM, uses pyagent/echo. Run with:
- .venv/bin/python -m tests.smoke_async_subagent
+ .venv/bin/python -m tests.test_async_subagent
"""
from __future__ import annotations
@@ -37,7 +37,7 @@
def main() -> None:
- tmp = Path(tempfile.mkdtemp(prefix="pyagent-async-smoke-"))
+ tmp = Path(tempfile.mkdtemp(prefix="pyagent-async-test-"))
os.chdir(tmp)
print(f"cwd: {tmp}")
@@ -72,17 +72,13 @@ def main() -> None:
"primer_path": str(tmp / "PRIMER.md"),
"approved_paths": [],
}
- spawn = subagent.make_spawn_subagent(
- state, agent, parent_session, base_config
- )
+ spawn = subagent.make_spawn_subagent(state, agent, parent_session, base_config)
call_sync = subagent.make_call_subagent(state, agent)
call_async = subagent.make_call_subagent_async(state, agent)
wait_for = subagent.make_wait_for_subagents(state, agent)
terminate = subagent.make_terminate_subagent(state, agent)
- io_thread = threading.Thread(
- target=state.io_loop, name="test-io", daemon=True
- )
+ io_thread = threading.Thread(target=state.io_loop, name="test-io", daemon=True)
io_thread.start()
sid = ""
@@ -119,9 +115,9 @@ def main() -> None:
assert entry.mode is None, entry.mode
with state._subagent_lock:
sync_q = state._subagent_reply_queues.get(sid)
- assert sync_q is not None and sync_q.empty(), (
- f"sync reply queue contaminated: {list(sync_q.queue)}"
- )
+ assert (
+ sync_q is not None and sync_q.empty()
+ ), f"sync reply queue contaminated: {list(sync_q.queue)}"
print("✓ entry.mode reset; sync queue uncontaminated")
# 6. Now a sync call works again on the same subagent.
diff --git a/tests/smoke_attachment_lru.py b/tests/test_attachment_lru.py
similarity index 93%
rename from tests/smoke_attachment_lru.py
rename to tests/test_attachment_lru.py
index 9747905..7aff625 100644
--- a/tests/smoke_attachment_lru.py
+++ b/tests/test_attachment_lru.py
@@ -30,7 +30,7 @@
implementation explicitly relies on.
No subprocess, no network. Run with:
- .venv/bin/python -m tests.smoke_attachment_lru
+ .venv/bin/python -m tests.test_attachment_lru
"""
from __future__ import annotations
@@ -53,9 +53,7 @@ def _dir_size(p: Path) -> int:
def _check_under_cap_no_eviction() -> None:
"""A handful of small writes keep dir under cap; everything stays."""
with tempfile.TemporaryDirectory(prefix="pyagent-lru-") as t:
- session = Session(
- session_id="under", root=Path(t), attachment_dir_cap_mb=5
- )
+ session = Session(session_id="under", root=Path(t), attachment_dir_cap_mb=5)
paths = []
for i in range(4):
# Each write is 200KB, four writes = 800KB << 5MB cap.
@@ -73,9 +71,7 @@ def _check_over_cap_oldest_atime_evicted() -> None:
"""Oldest-atime files go first when the dir crosses the cap."""
with tempfile.TemporaryDirectory(prefix="pyagent-lru-") as t:
# 3 MB cap, 1 MB writes — fourth write should trigger eviction.
- session = Session(
- session_id="over", root=Path(t), attachment_dir_cap_mb=3
- )
+ session = Session(session_id="over", root=Path(t), attachment_dir_cap_mb=3)
# First three writes: stamp each with a known atime so we can
# predict which one the eviction pass picks. Oldest first.
p1 = session.write_attachment("read_file", "1" * 1_100_000)
@@ -101,9 +97,7 @@ def _check_just_written_exempt_even_when_over_alone() -> None:
"""A single huge write that alone exceeds the cap stays; older
files are evicted but the just-written one is preserved."""
with tempfile.TemporaryDirectory(prefix="pyagent-lru-") as t:
- session = Session(
- session_id="huge", root=Path(t), attachment_dir_cap_mb=2
- )
+ session = Session(session_id="huge", root=Path(t), attachment_dir_cap_mb=2)
# Seed two small files with old atimes.
small1 = session.write_attachment("read_file", "x" * 500_000)
os.utime(small1, (1_000.0, 1_000.0))
@@ -144,15 +138,11 @@ def _check_just_written_exempt_even_when_over_alone() -> None:
def _check_cap_zero_disables_eviction() -> None:
"""cap=0 means "disabled" — no eviction ever runs."""
with tempfile.TemporaryDirectory(prefix="pyagent-lru-") as t:
- session = Session(
- session_id="off", root=Path(t), attachment_dir_cap_mb=0
- )
+ session = Session(session_id="off", root=Path(t), attachment_dir_cap_mb=0)
paths = []
# Write 5 MB worth of data; with cap disabled, all stays.
for _ in range(5):
- paths.append(
- session.write_attachment("read_file", "q" * 1_000_000)
- )
+ paths.append(session.write_attachment("read_file", "q" * 1_000_000))
for p in paths:
assert p.exists(), f"cap=0 should not evict, but {p} is gone"
total = _dir_size(session.attachments_dir)
@@ -171,9 +161,7 @@ def _check_config_wiring() -> None:
cap_mb = int(cfg.get("session", {}).get("attachment_dir_cap_mb", 25))
assert cap_mb == 5
with tempfile.TemporaryDirectory(prefix="pyagent-lru-") as t:
- session = Session(
- session_id="cfg", root=Path(t), attachment_dir_cap_mb=cap_mb
- )
+ session = Session(session_id="cfg", root=Path(t), attachment_dir_cap_mb=cap_mb)
assert session.attachment_dir_cap_mb == 5
# And confirm the config defaults expose the key (so users can see
@@ -247,7 +235,9 @@ def emit(self, record: logging.LogRecord) -> None:
# Non-numeric → warn, default.
handler.records.clear()
assert config_mod.resolve_attachment_dir_cap_mb("a lot") == 25
- assert any("integer" in r.getMessage() for r in handler.records), handler.records
+ assert any(
+ "integer" in r.getMessage() for r in handler.records
+ ), handler.records
finally:
cfg_logger.removeHandler(handler)
print("✓ validation: float / negative / bool / non-numeric warn and resolve sanely")
@@ -260,9 +250,7 @@ def _check_path_a_contract() -> None:
semantics; the existing not-found contract is the signal."""
with tempfile.TemporaryDirectory(prefix="pyagent-lru-") as t:
# 1 MB cap, 700 KB writes — second write triggers eviction of first.
- session = Session(
- session_id="path-a", root=Path(t), attachment_dir_cap_mb=1
- )
+ session = Session(session_id="path-a", root=Path(t), attachment_dir_cap_mb=1)
first = session.write_attachment("read_file", "F" * 700_000)
second = session.write_attachment("read_file", "S" * 700_000)
# First should be evicted; second is the just-written and stays.
diff --git a/tests/smoke_auto_venv.py b/tests/test_auto_venv.py
similarity index 95%
rename from tests/smoke_auto_venv.py
rename to tests/test_auto_venv.py
index 5e5a945..0962866 100644
--- a/tests/smoke_auto_venv.py
+++ b/tests/test_auto_venv.py
@@ -29,7 +29,7 @@
Run with:
- .venv/bin/python -m tests.smoke_auto_venv
+ .venv/bin/python -m tests.test_auto_venv
"""
from __future__ import annotations
@@ -77,13 +77,11 @@ def main() -> None:
os.environ["VIRTUAL_ENV"] = str(outside)
try:
found = venv_mod.discover(ws)
- assert found is None, (
- f"discover should ignore VIRTUAL_ENV; got {found}"
- )
+ assert found is None, f"discover should ignore VIRTUAL_ENV; got {found}"
desc = venv_mod.describe(ws)
- assert "(active)" not in desc, (
- f"describe should not advertise VIRTUAL_ENV; got {desc}"
- )
+ assert (
+ "(active)" not in desc
+ ), f"describe should not advertise VIRTUAL_ENV; got {desc}"
assert "none" in desc, desc
print("✓ VIRTUAL_ENV ignored when workspace has no venv")
finally:
@@ -204,8 +202,7 @@ def main() -> None:
assert data["venv_path"], data
assert data["exists_before_call"] is True, data
print(
- "✓ python_env(agent) reports active venv: "
- f"{data['venv_path']}"
+ "✓ python_env(agent) reports active venv: " f"{data['venv_path']}"
)
else:
assert data["venv_path"] == "", data
@@ -214,9 +211,9 @@ def main() -> None:
print("✓ python_env(agent) honestly reports no venv (system py)")
# Either way, the call must NOT have created
# `<workspace>/.venv` — agent scope never bootstraps.
- assert not (ws / ".venv").exists(), (
- "python_env(agent) should not touch the workspace"
- )
+ assert not (
+ ws / ".venv"
+ ).exists(), "python_env(agent) should not touch the workspace"
# 8. unknown scope rejected with marker
with tempfile.TemporaryDirectory() as tmp:
diff --git a/tests/smoke_background_exec.py b/tests/test_background_exec.py
similarity index 90%
rename from tests/smoke_background_exec.py
rename to tests/test_background_exec.py
index bd15e09..d065c9c 100644
--- a/tests/smoke_background_exec.py
+++ b/tests/test_background_exec.py
@@ -1,4 +1,4 @@
-"""Unit smoke for the background-shell tools.
+"""Unit test for the background-shell tools.
Covers the run_background / read_output / wait_for / kill_process
quartet end-to-end, plus the kill_active extension that flushes BOTH
@@ -6,7 +6,7 @@
Run with:
- .venv/bin/python -m tests.smoke_background_exec
+ .venv/bin/python -m tests.test_background_exec
"""
from __future__ import annotations
@@ -21,9 +21,7 @@
def _check_run_and_wait_exit() -> None:
"""run_background + wait_for(exit) returns rc and tail."""
- out = agent_tools.run_background(
- "echo hello-bg && exit 0", name="quick-echo"
- )
+ out = agent_tools.run_background("echo hello-bg && exit 0", name="quick-echo")
handle = re.search(r"started (bg-[0-9a-f]+)", out).group(1)
assert handle.startswith("bg-"), out
res = agent_tools.wait_for(handle, until="exit", timeout_s=5.0)
@@ -62,9 +60,7 @@ def _check_incremental_read_output() -> None:
def _check_output_contains() -> None:
"""wait_for(output_contains:STRING) returns when the substring lands."""
- started = agent_tools.run_background(
- "(sleep 0.2; echo READY-MARKER; sleep 5)"
- )
+ started = agent_tools.run_background("(sleep 0.2; echo READY-MARKER; sleep 5)")
handle = re.search(r"started (bg-[0-9a-f]+)", started).group(1)
t0 = time.monotonic()
res = agent_tools.wait_for(
@@ -81,14 +77,10 @@ def _check_silence_wait() -> None:
"""wait_for(silence:Ns) returns when output stops flowing."""
# Process emits 3 lines fast then goes quiet (sleeps 5s before
# the next line).
- started = agent_tools.run_background(
- "(echo a; echo b; echo c; sleep 5; echo d)"
- )
+ started = agent_tools.run_background("(echo a; echo b; echo c; sleep 5; echo d)")
handle = re.search(r"started (bg-[0-9a-f]+)", started).group(1)
t0 = time.monotonic()
- res = agent_tools.wait_for(
- handle, until="silence:0.5s", timeout_s=4.0
- )
+ res = agent_tools.wait_for(handle, until="silence:0.5s", timeout_s=4.0)
elapsed = time.monotonic() - t0
assert "settled" in res, res
# Should have settled within the 0.5s quiet window plus a little
@@ -120,7 +112,7 @@ def _check_kill_active_flushes_both() -> None:
handle = re.search(r"started (bg-[0-9a-f]+)", started).group(1)
assert handle in agent_tools._ACTIVE_BG_PROCS
- # Foreground sleep on a worker thread (mirrors smoke_kill_active).
+ # Foreground sleep on a worker thread (mirrors test_kill_active).
fg_result: dict = {}
def runner() -> None:
@@ -180,13 +172,11 @@ def _check_buffer_cap_truncation() -> None:
assert "rc=0" in res, res
bg = agent_tools._ACTIVE_BG_PROCS[handle]
# The cap is 1MB; 1.5MB written should leave dropped > 0.
- assert bg.dropped > 0, (
- f"expected output drops, got dropped={bg.dropped}"
- )
+ assert bg.dropped > 0, f"expected output drops, got dropped={bg.dropped}"
# And the buffer itself should be near (≤) the cap.
- assert len(bg.output_buf) <= 1024 * 1024, (
- f"buffer exceeded cap: {len(bg.output_buf)}"
- )
+ assert (
+ len(bg.output_buf) <= 1024 * 1024
+ ), f"buffer exceeded cap: {len(bg.output_buf)}"
out = agent_tools.read_output(handle, since=0, max_chars=200)
assert "...truncated" in out, out
# Post-truncation continuity: pulling next_since out of the first
@@ -196,12 +186,10 @@ def _check_buffer_cap_truncation() -> None:
# next_since should return an empty body and the same next_since.
next_since = int(re.search(r"next_since: (\d+)", out).group(1))
assert next_since > 0, out
- second = agent_tools.read_output(
- handle, since=next_since, max_chars=200
- )
- assert "...truncated" not in second, (
- f"unexpected truncation notice on continuation: {second!r}"
- )
+ second = agent_tools.read_output(handle, since=next_since, max_chars=200)
+ assert (
+ "...truncated" not in second
+ ), f"unexpected truncation notice on continuation: {second!r}"
second_next = int(re.search(r"next_since: (\d+)", second).group(1))
assert second_next == next_since, (
f"next_since regressed across post-truncation reads: "
@@ -239,9 +227,7 @@ def _check_dual_stream_read_output() -> None:
full = agent_tools.read_output(handle, since=0, max_chars=4000)
# Every line landed in the combined log.
for marker in ("OUT1", "OUT2", "OUT3", "ERR1", "ERR2", "ERR3"):
- assert marker in full, (
- f"expected {marker} in combined output, got: {full!r}"
- )
+ assert marker in full, f"expected {marker} in combined output, got: {full!r}"
# `[stderr]` / `[stdout]` markers appear when the source switches —
# the exact count depends on read1 timing, but at least one of each
# must show up.
@@ -279,9 +265,7 @@ def _check_shutdown_background_grace() -> None:
"""shutdown_background SIGTERMs then SIGKILLs the lingerers."""
# Trap SIGTERM in the child so it has to wait for the SIGKILL
# branch (verifies we don't hang past grace_s).
- started = agent_tools.run_background(
- "trap '' TERM; sleep 30"
- )
+ started = agent_tools.run_background("trap '' TERM; sleep 30")
handle = re.search(r"started (bg-[0-9a-f]+)", started).group(1)
t0 = time.monotonic()
signalled = agent_tools.shutdown_background(grace_s=0.2)
diff --git a/tests/smoke_bench_defaults.py b/tests/test_bench_defaults.py
similarity index 83%
rename from tests/smoke_bench_defaults.py
rename to tests/test_bench_defaults.py
index f6cd09c..8163540 100644
--- a/tests/smoke_bench_defaults.py
+++ b/tests/test_bench_defaults.py
@@ -5,7 +5,7 @@
vice versa). Doesn't run the bench — just checks the resolver.
Run with:
- .venv/bin/python -m tests.smoke_bench_defaults
+ .venv/bin/python -m tests.test_bench_defaults
"""
from __future__ import annotations
@@ -21,12 +21,8 @@ def _check_anthropic_tiers() -> None:
assert _default_budget_for("anthropic/claude-sonnet-4-6") == 0.50
# Haiku is cheap; smaller cap so a runaway Haiku run can't quietly
# cost more than the user expected.
- assert (
- _default_budget_for("anthropic/claude-haiku-4-5-20251001") == 0.20
- )
- print(
- "✓ Anthropic per-tier budgets: Opus $3.00 / Sonnet $0.50 / Haiku $0.20"
- )
+ assert _default_budget_for("anthropic/claude-haiku-4-5-20251001") == 0.20
+ print("✓ Anthropic per-tier budgets: Opus $3.00 / Sonnet $0.50 / Haiku $0.20")
def _check_other_providers() -> None:
@@ -36,8 +32,8 @@ def _check_other_providers() -> None:
# Gemini in the table.
assert _default_budget_for("gemini/gemini-2.5-flash") == 0.10
print(
- f"✓ Non-Anthropic budgets: gpt-4o $0.50 / gpt-4o-mini $0.10 / "
- f"gemini-flash $0.10"
+ "✓ Non-Anthropic budgets: gpt-4o $0.50 / gpt-4o-mini $0.10 / "
+ "gemini-flash $0.10"
)
diff --git a/tests/smoke_call_tool.py b/tests/test_call_tool.py
similarity index 91%
rename from tests/smoke_call_tool.py
rename to tests/test_call_tool.py
index abfe1aa..2c5de3b 100644
--- a/tests/smoke_call_tool.py
+++ b/tests/test_call_tool.py
@@ -11,7 +11,7 @@
Run with:
- .venv/bin/python -m tests.smoke_call_tool
+ .venv/bin/python -m tests.test_call_tool
"""
from __future__ import annotations
@@ -24,11 +24,9 @@
from pyagent import plugins as plugins_mod
-def _isolated_config_dir() -> tuple[Path, "callable"]:
+def _isolated_config_dir() -> tuple[Path, callable]:
tmp_cfg = Path(tempfile.mkdtemp(prefix="pyagent-call-tool-"))
- (tmp_cfg / "config.toml").write_text(
- "built_in_plugins_enabled = []\n"
- )
+ (tmp_cfg / "config.toml").write_text("built_in_plugins_enabled = []\n")
original_config = paths.config_dir
original_data = paths.data_dir
paths.config_dir = lambda: tmp_cfg # type: ignore[assignment]
@@ -52,19 +50,15 @@ def _write_plugin(
) -> Path:
pdir = plugins_root / dirname
pdir.mkdir(parents=True, exist_ok=True)
- tools_line = (
- "tools = ["
- + ", ".join(f'"{t}"' for t in provides_tools)
- + "]"
- )
+ tools_line = "tools = [" + ", ".join(f'"{t}"' for t in provides_tools) + "]"
manifest = (
f'name = "{name}"\n'
f'version = "0.1.0"\n'
- f'description = "{name} plugin (call_tool smoke)"\n'
+ f'description = "{name} plugin (call_tool test)"\n'
f'api_version = "1"\n\n'
"[provides]\n"
f"{tools_line}\n"
- 'prompt_sections = []\n\n'
+ "prompt_sections = []\n\n"
"[load]\n"
"in_subagents = true\n"
)
@@ -223,7 +217,7 @@ def test_depth_resets_between_calls() -> None:
"def register(api):\n"
" def echo(v: str) -> str:\n"
' """Echo the argument."""\n'
- ' return v\n'
+ " return v\n"
' api.register_tool("echo", echo)\n'
"\n"
" def deep() -> str:\n"
@@ -374,12 +368,18 @@ def test_called_tool_raises_returns_marker() -> None:
' api.register_tool("caller", caller)\n'
)
_write_plugin(
- cfg / "plugins", dirname="01-a", name="plug-boom",
- provides_tools=["boom"], plugin_py=plugin_a,
+ cfg / "plugins",
+ dirname="01-a",
+ name="plug-boom",
+ provides_tools=["boom"],
+ plugin_py=plugin_a,
)
_write_plugin(
- cfg / "plugins", dirname="02-b", name="plug-caller",
- provides_tools=["caller"], plugin_py=plugin_b,
+ cfg / "plugins",
+ dirname="02-b",
+ name="plug-caller",
+ provides_tools=["caller"],
+ plugin_py=plugin_b,
)
loaded = plugins_mod.load()
_, fn = loaded.tools()["caller"]
@@ -412,12 +412,18 @@ def test_bad_kwargs_returns_marker() -> None:
' api.register_tool("bad_kw_caller", caller)\n'
)
_write_plugin(
- cfg / "plugins", dirname="01-a", name="plug-bad-kwargs-target",
- provides_tools=["takes_x"], plugin_py=plugin_a,
+ cfg / "plugins",
+ dirname="01-a",
+ name="plug-bad-kwargs-target",
+ provides_tools=["takes_x"],
+ plugin_py=plugin_a,
)
_write_plugin(
- cfg / "plugins", dirname="02-b", name="plug-bad-kwargs-caller",
- provides_tools=["bad_kw_caller"], plugin_py=plugin_b,
+ cfg / "plugins",
+ dirname="02-b",
+ name="plug-bad-kwargs-caller",
+ provides_tools=["bad_kw_caller"],
+ plugin_py=plugin_b,
)
loaded = plugins_mod.load()
_, fn = loaded.tools()["bad_kw_caller"]
@@ -434,10 +440,18 @@ def test_bad_name_input() -> None:
a typed marker, never raises."""
state = plugins_mod._PluginState(
manifest=plugins_mod.Manifest(
- name="bare", version="0.0.1", description="bad-name",
- api_version="1", provides_tools=(), provides_prompt_sections=(),
- provides_providers=(), requires_python="", requires_env=(),
- requires_binaries=(), in_subagents=True, source=Path("/dev/null"),
+ name="bare",
+ version="0.0.1",
+ description="bad-name",
+ api_version="1",
+ provides_tools=(),
+ provides_prompt_sections=(),
+ provides_providers=(),
+ requires_python="",
+ requires_env=(),
+ requires_binaries=(),
+ in_subagents=True,
+ source=Path("/dev/null"),
)
)
api = plugins_mod.PluginAPI(state, loader=None)
@@ -489,12 +503,18 @@ def test_agent_registry_takes_precedence() -> None:
' api.register_tool("caller", caller)\n'
)
_write_plugin(
- cfg / "plugins", dirname="01-x", name="plug-x",
- provides_tools=["excluded_tool"], plugin_py=plugin_x,
+ cfg / "plugins",
+ dirname="01-x",
+ name="plug-x",
+ provides_tools=["excluded_tool"],
+ plugin_py=plugin_x,
)
_write_plugin(
- cfg / "plugins", dirname="02-y", name="plug-y",
- provides_tools=["caller"], plugin_py=plugin_y,
+ cfg / "plugins",
+ dirname="02-y",
+ name="plug-y",
+ provides_tools=["caller"],
+ plugin_py=plugin_y,
)
loaded = plugins_mod.load()
# Plugin loader sees BOTH tools.
diff --git a/tests/smoke_checklist.py b/tests/test_checklist.py
similarity index 80%
rename from tests/smoke_checklist.py
rename to tests/test_checklist.py
index 11362e1..4dd3d9a 100644
--- a/tests/smoke_checklist.py
+++ b/tests/test_checklist.py
@@ -7,7 +7,7 @@
Run with:
- .venv/bin/python -m tests.smoke_checklist
+ .venv/bin/python -m tests.test_checklist
"""
from __future__ import annotations
@@ -159,12 +159,19 @@ def main() -> None:
{
"type": "checklist",
"tasks": [
- {"id": "t-1", "title": "write migration",
- "status": "in_progress", "note": ""},
- {"id": "t-2", "title": "run tests",
- "status": "pending", "note": ""},
- {"id": "t-3", "title": "update README",
- "status": "pending", "note": ""},
+ {
+ "id": "t-1",
+ "title": "write migration",
+ "status": "in_progress",
+ "note": "",
+ },
+ {"id": "t-2", "title": "run tests", "status": "pending", "note": ""},
+ {
+ "id": "t-3",
+ "title": "update README",
+ "status": "pending",
+ "note": "",
+ },
],
},
)
@@ -179,12 +186,24 @@ def main() -> None:
{
"type": "checklist",
"tasks": [
- {"id": "t-1", "title": "write migration",
- "status": "completed", "note": ""},
- {"id": "t-2", "title": "run tests",
- "status": "in_progress", "note": ""},
- {"id": "t-3", "title": "update README",
- "status": "pending", "note": ""},
+ {
+ "id": "t-1",
+ "title": "write migration",
+ "status": "completed",
+ "note": "",
+ },
+ {
+ "id": "t-2",
+ "title": "run tests",
+ "status": "in_progress",
+ "note": "",
+ },
+ {
+ "id": "t-3",
+ "title": "update README",
+ "status": "pending",
+ "note": "",
+ },
],
},
)
@@ -198,10 +217,8 @@ def main() -> None:
{
"type": "checklist",
"tasks": [
- {"id": "t-1", "title": "x",
- "status": "completed", "note": ""},
- {"id": "t-2", "title": "y",
- "status": "completed", "note": ""},
+ {"id": "t-1", "title": "x", "status": "completed", "note": ""},
+ {"id": "t-2", "title": "y", "status": "completed", "note": ""},
],
},
)
@@ -218,10 +235,8 @@ def main() -> None:
{
"type": "checklist",
"tasks": [
- {"id": "t-1", "title": long_title,
- "status": "in_progress", "note": ""},
- {"id": "t-2", "title": "next",
- "status": "pending", "note": ""},
+ {"id": "t-1", "title": long_title, "status": "in_progress", "note": ""},
+ {"id": "t-2", "title": "next", "status": "pending", "note": ""},
],
},
)
@@ -236,12 +251,24 @@ def main() -> None:
{
"type": "checklist",
"tasks": [
- {"id": "t-1", "title": "design schema",
- "status": "completed", "note": "reviewed in PR"},
- {"id": "t-2", "title": "write migration",
- "status": "in_progress", "note": ""},
- {"id": "t-3", "title": "abandoned approach",
- "status": "cancelled", "note": "supplanted by t-2"},
+ {
+ "id": "t-1",
+ "title": "design schema",
+ "status": "completed",
+ "note": "reviewed in PR",
+ },
+ {
+ "id": "t-2",
+ "title": "write migration",
+ "status": "in_progress",
+ "note": "",
+ },
+ {
+ "id": "t-3",
+ "title": "abandoned approach",
+ "status": "cancelled",
+ "note": "supplanted by t-2",
+ },
],
},
)
@@ -249,6 +276,7 @@ def main() -> None:
captured = Console(file=buf, force_terminal=False, color_system=None)
# Patch the module's `console` so _print_tasks renders into our buf.
import pyagent.cli as cli_mod
+
real_console = cli_mod.console
cli_mod.console = captured
try:
diff --git a/tests/smoke_claude_code_cli.py b/tests/test_claude_code_cli.py
similarity index 96%
rename from tests/smoke_claude_code_cli.py
rename to tests/test_claude_code_cli.py
index 09306d6..fc3ad82 100644
--- a/tests/smoke_claude_code_cli.py
+++ b/tests/test_claude_code_cli.py
@@ -7,7 +7,7 @@
Run with:
- .venv/bin/python -m tests.smoke_claude_code_cli
+ .venv/bin/python -m tests.test_claude_code_cli
"""
from __future__ import annotations
@@ -18,8 +18,8 @@
# Import the plugin module directly so we can drive its inner tool
# function without booting the full plugin loader (which gates on
# `claude` being on PATH via the manifest's [requires] binaries list).
-PLUGIN_DIR = Path(
- "/home/derek/src/pyagent/pyagent/plugins/claude_code_cli"
+PLUGIN_DIR = (
+ Path(__file__).resolve().parent.parent / "pyagent" / "plugins" / "claude_code_cli"
)
spec = importlib.util.spec_from_file_location(
"claude_code_cli_under_test",
@@ -37,7 +37,7 @@ class _StubAPI:
def __init__(self) -> None:
self.tools: dict = {}
- def register_tool(self, name: str, fn) -> None:
+ def register_tool(self, name: str, fn, *, role_only: bool = False) -> None:
self.tools[name] = fn
@@ -79,9 +79,7 @@ def test_oversize_json_schema_rejected() -> None:
they ever hit argv (where they'd otherwise blow ARG_MAX)."""
tool = _get_tool()
huge = {"properties": {f"f{i}": {"type": "string"} for i in range(8000)}}
- out = tool(
- prompt="hi", output_format="json", json_schema=huge
- )
+ out = tool(prompt="hi", output_format="json", json_schema=huge)
assert "json_schema exceeds" in out
assert "chars" in out
print("✓ oversize json_schema rejected")
@@ -101,7 +99,7 @@ def test_unserializable_json_schema_rejected() -> None:
def test_oversize_context_file_rejected(tmp_path: Path | None = None) -> None:
import tempfile
- tmp = Path(tempfile.mkdtemp(prefix="smoke-claude-cli-"))
+ tmp = Path(tempfile.mkdtemp(prefix="test-claude-cli-"))
try:
big = tmp / "big.txt"
# Just over the cap — char-mode read makes this a 1-MiB+1-char
diff --git a/tests/smoke_cli_render.py b/tests/test_cli_render.py
similarity index 95%
rename from tests/smoke_cli_render.py
rename to tests/test_cli_render.py
index 3747249..320f18f 100644
--- a/tests/smoke_cli_render.py
+++ b/tests/test_cli_render.py
@@ -1,4 +1,4 @@
-"""End-to-end smoke for the CLI's per-event rendering choices that
+"""End-to-end test for the CLI's per-event rendering choices that
came out of issue #111.
Concerns:
@@ -23,7 +23,7 @@
Run with:
- .venv/bin/python -m tests.smoke_cli_render
+ .venv/bin/python -m tests.test_cli_render
"""
from __future__ import annotations
@@ -72,8 +72,10 @@ def _check_streaming_assistant_text_walks_back_and_renders_markdown() -> None:
cli._streaming_rendered_rows["root"] = 3
buf = io.StringIO()
- with mock.patch.object(sys, "stdout", buf), \
- mock.patch.object(cli.console, "print") as fake_print:
+ with (
+ mock.patch.object(sys, "stdout", buf),
+ mock.patch.object(cli.console, "print") as fake_print,
+ ):
cli._print_event({"type": "assistant_text", "text": "**hi**"})
out = buf.getvalue()
@@ -109,9 +111,12 @@ def _check_on_text_delta_renders_cumulatively() -> None:
# Force a wide-enough terminal that "Hello"/"Hello!" each fit
# on one row → first render = 1 row, walk-back = \x1b[1F.
- with mock.patch.object(
- cli.shutil, "get_terminal_size", return_value=os.terminal_size((80, 24))
- ), mock.patch.object(cli.console, "print") as fake_print:
+ with (
+ mock.patch.object(
+ cli.shutil, "get_terminal_size", return_value=os.terminal_size((80, 24))
+ ),
+ mock.patch.object(cli.console, "print") as fake_print,
+ ):
buf = io.StringIO()
with mock.patch.object(sys, "stdout", buf):
cli._on_text_delta("Hello", agent_id=None)
@@ -335,9 +340,7 @@ def _check_tool_result_renders_success_and_error() -> None:
# Error path: prints dim red, flips accumulator entry to ok=False.
cli._turn_tool_calls[:] = [{"name": "glob", "ok": True}]
with mock.patch.object(cli.console, "print") as fake_print:
- cli._on_tool_result(
- "glob", "Error: no matches\n", agent_id=None
- )
+ cli._on_tool_result("glob", "Error: no matches\n", agent_id=None)
line = fake_print.call_args.args[0]
_check(
"error result renders dim red ↳",
@@ -360,7 +363,8 @@ def _check_tool_result_renders_success_and_error() -> None:
cli._on_tool_result("glob", "Error: x", agent_id=None)
_check(
"LIFO error match flips only the most recent matching call",
- cli._turn_tool_calls == [
+ cli._turn_tool_calls
+ == [
{"name": "glob", "ok": True},
{"name": "glob", "ok": False},
],
@@ -394,9 +398,7 @@ def _check_turn_summary_renders_and_clears() -> None:
line = fake_print.call_args.args[0]
_check(
"summary renders all three tools with ✓/✗ markers",
- "create_memory ✓" in line
- and "glob ✗" in line
- and "execute ✓" in line,
+ "create_memory ✓" in line and "glob ✗" in line and "execute ✓" in line,
repr(line),
)
_check(
@@ -430,7 +432,7 @@ def main() -> None:
_check_tool_call_renders_visibly_and_accumulates()
_check_tool_result_renders_success_and_error()
_check_turn_summary_renders_and_clears()
- print("smoke_cli_render: all checks passed")
+ print("test_cli_render: all checks passed")
if __name__ == "__main__":
diff --git a/tests/smoke_code_mapper.py b/tests/test_code_mapper.py
similarity index 88%
rename from tests/smoke_code_mapper.py
rename to tests/test_code_mapper.py
index 13b3d8e..4803267 100644
--- a/tests/smoke_code_mapper.py
+++ b/tests/test_code_mapper.py
@@ -1,4 +1,4 @@
-"""End-to-end smoke for the code-mapper plugin.
+"""End-to-end test for the code-mapper plugin.
Three concerns:
@@ -15,7 +15,7 @@
Run with:
- .venv/bin/python -m tests.smoke_code_mapper
+ .venv/bin/python -m tests.test_code_mapper
"""
from __future__ import annotations
@@ -32,7 +32,6 @@
)
from pyagent.plugins.code_mapper import mapper
-
_CLEAN_PY = b'''"""Module docstring."""
import os
@@ -63,7 +62,7 @@ def inner():
'''
-_BROKEN_PY = b'''import os
+_BROKEN_PY = b"""import os
def good():
return 1
@@ -74,7 +73,7 @@ def fine(self):
def broken(self
# missing close-paren and body
-'''
+"""
def _check_map_clean_python() -> None:
@@ -141,29 +140,25 @@ def _check_kind_filter() -> None:
kinds = {s["kind"] for s in out["symbols"]}
assert kinds == {"class"}, kinds
- print(f"✓ kind= filter narrows symbol set as documented")
+ print("✓ kind= filter narrows symbol set as documented")
def _check_docstrings_optin() -> None:
out_off = mapper.map_source(_CLEAN_PY, "python", kind="functions")
- assert all("docstring" not in s for s in out_off["symbols"]), (
- out_off["symbols"]
- )
+ assert all("docstring" not in s for s in out_off["symbols"]), out_off["symbols"]
out_on = mapper.map_source(
_CLEAN_PY, "python", kind="functions", include_docstrings=True
)
by_name = {s["name"]: s for s in out_on["symbols"]}
- assert by_name["speak"]["docstring"].strip() == "Make a sound.", (
- by_name["speak"]
- )
+ assert by_name["speak"]["docstring"].strip() == "Make a sound.", by_name["speak"]
assert by_name["top_level"]["docstring"].strip() == (
"A top-level function."
), by_name["top_level"]
# `name` method has no docstring → field absent or None.
name_doc = by_name["name"].get("docstring")
assert name_doc is None, name_doc
- print(f"✓ include_docstrings=True attaches docstrings; default omits them")
+ print("✓ include_docstrings=True attaches docstrings; default omits them")
def _check_broken_python_degrades() -> None:
@@ -186,27 +181,25 @@ def _check_broken_python_degrades() -> None:
def _check_unsupported_extension() -> None:
"""`map_code_for_path` should return a clean error payload, not
raise, for an extension we don't ship a grammar/query for."""
- out_str = mapper.map_code_for_path(
- "/tmp/whatever.foo", b"junk", kind="all"
- )
+ out_str = mapper.map_code_for_path("/tmp/whatever.foo", b"junk", kind="all")
payload = json.loads(out_str)
assert "error" in payload, payload
assert ".foo" in payload["error"], payload["error"]
- print(f"✓ unsupported extension → clean error payload")
+ print("✓ unsupported extension → clean error payload")
def _check_plugin_loads_under_default_config() -> None:
"""With the default config, code-mapper is in
built_in_plugins_enabled and load() exposes the map_code tool."""
- tmp = Path(tempfile.mkdtemp(prefix="pyagent-smoke-codemapper-"))
+ tmp = Path(tempfile.mkdtemp(prefix="pyagent-test-codemapper-"))
with mock.patch.object(paths_mod, "config_dir", return_value=tmp):
with mock.patch.object(
plugins, "LOCAL_PLUGINS_DIR", Path(tmp / "no_local_plugins")
):
cfg = config_mod.load()
- assert "code-mapper" in cfg["built_in_plugins_enabled"], (
- cfg["built_in_plugins_enabled"]
- )
+ assert "code-mapper" in cfg["built_in_plugins_enabled"], cfg[
+ "built_in_plugins_enabled"
+ ]
loaded = plugins.load()
tool_names = set(loaded.tools().keys())
assert "map_code" in tool_names, tool_names
@@ -220,9 +213,7 @@ def _check_end_to_end_against_real_file() -> None:
if not target.exists():
print(f" (skipped: {target} not found)")
return
- out_str = mapper.map_code_for_path(
- str(target), target.read_bytes(), kind="classes"
- )
+ out_str = mapper.map_code_for_path(str(target), target.read_bytes(), kind="classes")
payload = json.loads(out_str)
assert payload["file"] == str(target)
assert payload["language"] == "python", payload
@@ -232,7 +223,7 @@ def _check_end_to_end_against_real_file() -> None:
print(f"✓ end-to-end on pyagent/agent.py → classes: {names}")
-_RUST_SRC = b'''use std::io;
+_RUST_SRC = b"""use std::io;
struct Point { x: i32, y: i32 }
@@ -253,7 +244,7 @@ def _check_end_to_end_against_real_file() -> None:
}
fn top() {}
-'''
+"""
def _check_map_rust() -> None:
@@ -285,10 +276,10 @@ def _check_map_rust() -> None:
assert has("impl", "Greet", None), out["symbols"]
assert has("function", "top", None), out["symbols"]
- print(f"✓ Rust: struct/enum/trait/method/function classified correctly")
+ print("✓ Rust: struct/enum/trait/method/function classified correctly")
-_C_SRC = b'''#include <stdio.h>
+_C_SRC = b"""#include <stdio.h>
typedef struct point { int x, y; } point_t;
@@ -299,7 +290,7 @@ def _check_map_rust() -> None:
int add(int a, int b) { return a + b; }
static void greet(const char *name) { printf("hi"); }
-'''
+"""
def _check_map_c() -> None:
@@ -312,10 +303,10 @@ def _check_map_c() -> None:
assert by_name["token"]["kind"] == "union", by_name["token"]
assert by_name["add"]["kind"] == "function", by_name["add"]
assert by_name["greet"]["kind"] == "function", by_name["greet"]
- print(f"✓ C: struct/typedef/enum/union/function classified correctly")
+ print("✓ C: struct/typedef/enum/union/function classified correctly")
-_CPP_SRC = b'''namespace app {
+_CPP_SRC = b"""namespace app {
class Animal {
public:
@@ -330,7 +321,7 @@ class Animal {
void top() {}
} // namespace app
-'''
+"""
def _check_map_cpp() -> None:
@@ -348,17 +339,15 @@ def _check_map_cpp() -> None:
speak_in_animal = [
s
for s in out["symbols"]
- if s["kind"] == "method"
- and s["name"] == "speak"
- and s["parent"] == "Animal"
+ if s["kind"] == "method" and s["name"] == "speak" and s["parent"] == "Animal"
]
assert len(speak_in_animal) == 2, speak_in_animal
# Free function inside namespace.
assert has("function", "top", "app"), out["symbols"]
- print(f"✓ C++: class/struct/method (in-class + out-of-line)/namespace OK")
+ print("✓ C++: class/struct/method (in-class + out-of-line)/namespace OK")
-_HTML_SRC = b'''<!doctype html>
+_HTML_SRC = b"""<!doctype html>
<html><body>
<main id="top">
<h1>Title</h1>
@@ -369,7 +358,7 @@ def _check_map_cpp() -> None:
<style>p { color: red; }</style>
</main>
</body></html>
-'''
+"""
def _check_map_html() -> None:
@@ -397,7 +386,7 @@ def _check_map_html() -> None:
)
-_TYPESCRIPT_SRC = b'''class Foo {
+_TYPESCRIPT_SRC = b"""class Foo {
bar() { return 1; }
static baz() { return 2; }
}
@@ -407,7 +396,7 @@ def _check_map_html() -> None:
function freeFn() {}
const arrow = () => 1;
namespace App { export const x = 1; }
-'''
+"""
def _check_map_typescript() -> None:
@@ -426,14 +415,14 @@ def _check_map_typescript() -> None:
assert has("function", "freeFn", None), out["symbols"]
assert has("function", "arrow", None), out["symbols"]
assert has("module", "App", None), out["symbols"]
- print(f"✓ TypeScript: class/method/interface/enum/type/function/module")
+ print("✓ TypeScript: class/method/interface/enum/type/function/module")
-_TSX_SRC = b'''function App() { return <div>Hi</div>; }
+_TSX_SRC = b"""function App() { return <div>Hi</div>; }
class Comp { render() { return null; } }
const Btn = () => <button/>;
interface Props { name: string; }
-'''
+"""
def _check_map_tsx() -> None:
@@ -448,14 +437,14 @@ def _check_map_tsx() -> None:
assert has("method", "render", "Comp"), out["symbols"]
assert has("function", "Btn", None), out["symbols"]
assert has("interface", "Props", None), out["symbols"]
- print(f"✓ TSX: JSX functions / class component / arrow component")
+ print("✓ TSX: JSX functions / class component / arrow component")
-_JAVASCRIPT_SRC = b'''class Foo { bar() { return 1; } static baz() {} }
+_JAVASCRIPT_SRC = b"""class Foo { bar() { return 1; } static baz() {} }
function freeFn() {}
const arrow = () => 1;
function* gen() { yield 1; }
-'''
+"""
def _check_map_javascript() -> None:
@@ -471,10 +460,10 @@ def _check_map_javascript() -> None:
assert has("function", "freeFn", None), out["symbols"]
assert has("function", "arrow", None), out["symbols"]
assert has("function", "gen", None), out["symbols"]
- print(f"✓ JavaScript: class/method/function/arrow/generator")
+ print("✓ JavaScript: class/method/function/arrow/generator")
-_GO_SRC = b'''package main
+_GO_SRC = b"""package main
import "fmt"
@@ -487,7 +476,7 @@ def _check_map_javascript() -> None:
func (p *Point) Distance() int { return 0 }
func main() { fmt.Println("hi") }
-'''
+"""
def _check_map_go() -> None:
@@ -509,10 +498,10 @@ def _check_map_go() -> None:
distance = [s for s in out["symbols"] if s["name"] == "Distance"]
assert len(distance) == 1 and distance[0]["kind"] == "method", distance
assert has("function", "main", None), out["symbols"]
- print(f"✓ Go: package/struct/interface/type/const/var/method/function")
+ print("✓ Go: package/struct/interface/type/const/var/method/function")
-_JAVA_SRC = b'''package com.example;
+_JAVA_SRC = b"""package com.example;
public class Foo {
private int count;
@@ -524,7 +513,7 @@ def _check_map_go() -> None:
interface IThing { void doIt(); }
enum Color { RED, GREEN }
record Pair(int x, int y) {}
-'''
+"""
def _check_map_java() -> None:
@@ -543,10 +532,10 @@ def _check_map_java() -> None:
assert has("method", "doIt", "IThing"), out["symbols"]
assert has("enum", "Color", None), out["symbols"]
assert has("record", "Pair", None), out["symbols"]
- print(f"✓ Java: class/field/method/constructor/interface/enum/record")
+ print("✓ Java: class/field/method/constructor/interface/enum/record")
-_BASH_SRC = b'''#!/bin/bash
+_BASH_SRC = b"""#!/bin/bash
PORT=8080
NAME="world"
@@ -557,7 +546,7 @@ def _check_map_java() -> None:
run_server() {
python -m http.server $PORT
}
-'''
+"""
def _check_map_bash() -> None:
@@ -568,10 +557,10 @@ def _check_map_bash() -> None:
assert by_name["NAME"]["kind"] == "variable", by_name["NAME"]
assert by_name["greet"]["kind"] == "function", by_name["greet"]
assert by_name["run_server"]["kind"] == "function", by_name["run_server"]
- print(f"✓ Bash: function + variable_assignment")
+ print("✓ Bash: function + variable_assignment")
-_RUBY_SRC = b'''module Greeter
+_RUBY_SRC = b"""module Greeter
class Animal
def speak
"hi"
@@ -586,7 +575,7 @@ def self.species
def top_level
1
end
-'''
+"""
def _check_map_ruby() -> None:
@@ -601,17 +590,17 @@ def _check_map_ruby() -> None:
assert has("method", "speak", "Animal"), out["symbols"]
assert has("method", "species", "Animal"), out["symbols"]
assert has("method", "top_level", None), out["symbols"]
- print(f"✓ Ruby: module/class/method (incl. singleton methods)")
+ print("✓ Ruby: module/class/method (incl. singleton methods)")
-_JSON_SRC = b'''{
+_JSON_SRC = b"""{
"name": "foo",
"version": "1.0",
"deps": {
"left-pad": "1.0",
"react": "18.0"
}
-}'''
+}"""
def _check_map_json() -> None:
@@ -625,17 +614,17 @@ def _check_map_json() -> None:
assert has("field", "deps", None), out["symbols"]
assert has("field", "left-pad", "deps"), out["symbols"]
assert has("field", "react", "deps"), out["symbols"]
- print(f"✓ JSON: top-level + nested fields with parent attribution")
+ print("✓ JSON: top-level + nested fields with parent attribution")
-_YAML_SRC = b'''name: my-app
+_YAML_SRC = b"""name: my-app
version: 1.0
deps:
left-pad: 1.0
react:
version: 18.0
peer: true
-'''
+"""
def _check_map_yaml() -> None:
@@ -650,10 +639,10 @@ def _check_map_yaml() -> None:
assert has("field", "left-pad", "deps"), out["symbols"]
assert has("field", "react", "deps"), out["symbols"]
assert has("field", "version", "react"), out["symbols"]
- print(f"✓ YAML: nested mapping keys with parent attribution")
+ print("✓ YAML: nested mapping keys with parent attribution")
-_TOML_SRC = b'''name = "my-app"
+_TOML_SRC = b"""name = "my-app"
version = "1.0"
[deps]
@@ -665,7 +654,7 @@ def _check_map_yaml() -> None:
[deps.dev]
pytest = "7.0"
-'''
+"""
def _check_map_toml() -> None:
@@ -683,10 +672,10 @@ def _check_map_toml() -> None:
assert has("field", "id", "plugins"), out["symbols"]
assert has("module", "deps.dev", None), out["symbols"]
assert has("field", "pytest", "deps.dev"), out["symbols"]
- print(f"✓ TOML: section headers (incl. dotted) + pairs with attribution")
+ print("✓ TOML: section headers (incl. dotted) + pairs with attribution")
-_MARKDOWN_SRC = b'''# Title
+_MARKDOWN_SRC = b"""# Title
Some intro text.
@@ -699,7 +688,7 @@ def _check_map_toml() -> None:
## Section B
#### too-deep heading
-'''
+"""
def _check_map_markdown() -> None:
@@ -715,10 +704,10 @@ def _check_map_markdown() -> None:
assert "too-deep heading" not in names, out["symbols"]
kinds = {s["kind"] for s in out["symbols"]}
assert kinds == {"heading"}, kinds
- print(f"✓ Markdown: H1-H3 headings, H4+ excluded")
+ print("✓ Markdown: H1-H3 headings, H4+ excluded")
-_DOCKERFILE_SRC = b'''FROM python:3.11 AS builder
+_DOCKERFILE_SRC = b"""FROM python:3.11 AS builder
WORKDIR /app
COPY . .
RUN pip install -r reqs.txt
@@ -728,7 +717,7 @@ def _check_map_markdown() -> None:
ENV PORT=8080
EXPOSE 8080
CMD ["python", "app.py"]
-'''
+"""
def _check_map_dockerfile() -> None:
@@ -741,10 +730,10 @@ def _check_map_dockerfile() -> None:
assert ("directive", "RUN") in by, by
assert ("directive", "ENV") in by, by
assert ("directive", "CMD") in by, by
- print(f"✓ Dockerfile: stages + per-instruction directives")
+ print("✓ Dockerfile: stages + per-instruction directives")
-_SWIFT_SRC = b'''class Animal {
+_SWIFT_SRC = b"""class Animal {
var name: String = ""
func speak() {}
}
@@ -754,7 +743,7 @@ def _check_map_dockerfile() -> None:
}
func top() {}
-'''
+"""
def _check_map_swift() -> None:
@@ -770,10 +759,10 @@ def _check_map_swift() -> None:
assert has("interface", "Greet", None), out["symbols"]
assert has("method", "hi", "Greet"), out["symbols"]
assert has("function", "top", None), out["symbols"]
- print(f"✓ Swift: class/property/method/protocol/function")
+ print("✓ Swift: class/property/method/protocol/function")
-_KOTLIN_SRC = b'''class Foo {
+_KOTLIN_SRC = b"""class Foo {
fun bar() = 1
fun baz(x: Int): String = "hi"
}
@@ -783,7 +772,7 @@ def _check_map_swift() -> None:
}
fun top() = 2
-'''
+"""
def _check_map_kotlin() -> None:
@@ -799,10 +788,10 @@ def _check_map_kotlin() -> None:
assert has("object", "Greeter", None), out["symbols"]
assert has("method", "greet", "Greeter"), out["symbols"]
assert has("function", "top", None), out["symbols"]
- print(f"✓ Kotlin: class/method/object/function")
+ print("✓ Kotlin: class/method/object/function")
-_SCALA_SRC = b'''package mypkg
+_SCALA_SRC = b"""package mypkg
class Foo(val x: Int) {
def bar(): Int = x
@@ -817,7 +806,7 @@ def greet(): String
}
def topLevel() = 1
-'''
+"""
def _check_map_scala() -> None:
@@ -835,10 +824,10 @@ def _check_map_scala() -> None:
assert has("trait", "Greeter", None), out["symbols"]
assert has("method", "greet", "Greeter"), out["symbols"]
assert has("function", "topLevel", None), out["symbols"]
- print(f"✓ Scala: package/class/object/trait/method/function")
+ print("✓ Scala: package/class/object/trait/method/function")
-_LUA_SRC = b'''function top()
+_LUA_SRC = b"""function top()
return 1
end
@@ -855,7 +844,7 @@ def _check_map_scala() -> None:
local M = {
helper = function() end,
}
-'''
+"""
def _check_map_lua() -> None:
@@ -867,10 +856,10 @@ def _check_map_lua() -> None:
assert by_name["meth"]["kind"] == "method", by_name["meth"]
assert by_name["f"]["kind"] == "function", by_name["f"]
assert by_name["helper"]["kind"] == "function", by_name["helper"]
- print(f"✓ Lua: function (plain/dotted/local/table) + method (colon)")
+ print("✓ Lua: function (plain/dotted/local/table) + method (colon)")
-_PHP_SRC = b'''<?php
+_PHP_SRC = b"""<?php
class Foo {
public function bar() { return 1; }
@@ -880,7 +869,7 @@ class Foo {
interface IThing { public function doIt(); }
trait Greetable { public function greet() {} }
function top() { return 3; }
-'''
+"""
def _check_map_php() -> None:
@@ -898,10 +887,10 @@ def _check_map_php() -> None:
assert has("trait", "Greetable", None), out["symbols"]
assert has("method", "greet", "Greetable"), out["symbols"]
assert has("function", "top", None), out["symbols"]
- print(f"✓ PHP: class/method/interface/trait/function")
+ print("✓ PHP: class/method/interface/trait/function")
-_CSS_SRC = b'''.btn { color: red; }
+_CSS_SRC = b""".btn { color: red; }
#header { background: blue; }
.btn-primary { color: white; }
@@ -917,7 +906,7 @@ def _check_map_php() -> None:
@font-face {
src: url(x.ttf);
}
-'''
+"""
def _check_map_css() -> None:
@@ -930,16 +919,16 @@ def _check_map_css() -> None:
assert ("at_rule", "@media") in by, by
assert ("at_rule", "spin") in by, by
assert ("at_rule", "@font-face") in by, by
- print(f"✓ CSS: class/id selectors + at-rules (@media / @keyframes / @font-face)")
+ print("✓ CSS: class/id selectors + at-rules (@media / @keyframes / @font-face)")
-_SQL_SRC = b'''CREATE TABLE users (id INT, name TEXT);
+_SQL_SRC = b"""CREATE TABLE users (id INT, name TEXT);
CREATE VIEW recent_users AS SELECT * FROM users;
CREATE INDEX idx_users_name ON users(name);
CREATE FUNCTION fn() RETURNS INT AS $$ SELECT 1 $$ LANGUAGE sql;
CREATE SCHEMA reporting;
CREATE TRIGGER audit_trg BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION fn();
-'''
+"""
def _check_map_sql() -> None:
@@ -953,7 +942,7 @@ def _check_map_sql() -> None:
assert ("function", "fn") in by, by
assert ("schema", "reporting") in by, by
assert ("trigger", "audit_trg") in by, by
- print(f"✓ SQL: table/view/index/function/schema/trigger")
+ print("✓ SQL: table/view/index/function/schema/trigger")
def _check_probe_grammar() -> None:
@@ -975,15 +964,13 @@ def _check_probe_grammar() -> None:
assert "function_declaration" in out or "function_definition" in out, out
# max_nodes bounds output.
- out = mapper.probe_grammar(
- "python", "a=1\nb=2\nc=3\nd=4\ne=5", max_nodes=4
- )
+ out = mapper.probe_grammar("python", "a=1\nb=2\nc=3\nd=4\ne=5", max_nodes=4)
assert "truncated" in out, out
# Unknown language returns a clean error marker, not an exception.
err = mapper.probe_grammar("klingon", "qapla")
assert err.startswith("<unknown language"), err
- print(f"✓ probe_grammar: field names visible, bounded, language-pack-direct")
+ print("✓ probe_grammar: field names visible, bounded, language-pack-direct")
def _check_extension_dispatch() -> None:
@@ -991,29 +978,47 @@ def _check_extension_dispatch() -> None:
exts = set(mapper.supported_extensions())
for required in (
# v1 base set
- ".py", ".pyi",
+ ".py",
+ ".pyi",
".rs",
- ".c", ".h",
- ".cc", ".cpp", ".cxx", ".hh", ".hpp", ".hxx",
- ".html", ".htm",
+ ".c",
+ ".h",
+ ".cc",
+ ".cpp",
+ ".cxx",
+ ".hh",
+ ".hpp",
+ ".hxx",
+ ".html",
+ ".htm",
# tier 1 — most common
- ".ts", ".mts", ".cts",
+ ".ts",
+ ".mts",
+ ".cts",
".tsx",
- ".js", ".mjs", ".cjs", ".jsx",
+ ".js",
+ ".mjs",
+ ".cjs",
+ ".jsx",
".go",
".java",
- ".sh", ".bash",
+ ".sh",
+ ".bash",
".rb",
# tier 2 — config / data formats
".json",
- ".yaml", ".yml",
+ ".yaml",
+ ".yml",
".toml",
- ".md", ".markdown",
+ ".md",
+ ".markdown",
".dockerfile",
# tier 3 — broader coverage
".swift",
- ".kt", ".kts",
- ".scala", ".sc",
+ ".kt",
+ ".kts",
+ ".scala",
+ ".sc",
".lua",
".php",
".css",
@@ -1059,7 +1064,7 @@ def main() -> None:
_check_map_sql()
_check_probe_grammar()
_check_extension_dispatch()
- print("smoke_code_mapper: all checks passed")
+ print("test_code_mapper: all checks passed")
if __name__ == "__main__":
diff --git a/tests/smoke_context_window.py b/tests/test_context_window.py
similarity index 96%
rename from tests/smoke_context_window.py
rename to tests/test_context_window.py
index 9a99b90..4897579 100644
--- a/tests/smoke_context_window.py
+++ b/tests/test_context_window.py
@@ -1,4 +1,4 @@
-"""End-to-end smoke for the per-model context-window awareness.
+"""End-to-end test for the per-model context-window awareness.
Concerns:
@@ -26,7 +26,7 @@
Run with:
- .venv/bin/python -m tests.smoke_context_window
+ .venv/bin/python -m tests.test_context_window
"""
from __future__ import annotations
@@ -130,9 +130,7 @@ def fake_post(url, json=None, timeout=None, stream=False):
)
c = ollama_client_mod.OllamaClient(model="llama3.2")
- with mock.patch.object(
- ollama_client_mod.requests, "post", side_effect=fake_post
- ):
+ with mock.patch.object(ollama_client_mod.requests, "post", side_effect=fake_post):
first = c.context_window
second = c.context_window
third = c.context_window
@@ -230,9 +228,8 @@ def send(self, event_type, **payload):
_emit_context_status(state, _Agent(_Client(200_000), used=100_000))
_check(
"50% utilization emits context_status only",
- state.events == [
- ("context_status", {"pct": 50, "used": 100_000, "window": 200_000})
- ],
+ state.events
+ == [("context_status", {"pct": 50, "used": 100_000, "window": 200_000})],
repr(state.events),
)
@@ -372,7 +369,7 @@ def main() -> None:
_check_ollama_lazy_show_fetch_and_cache()
_check_emit_context_status_shape()
_check_context_segment_renders()
- print("smoke_context_window: all checks passed")
+ print("test_context_window: all checks passed")
if __name__ == "__main__":
diff --git a/tests/smoke_controlling_hooks.py b/tests/test_controlling_hooks.py
similarity index 84%
rename from tests/smoke_controlling_hooks.py
rename to tests/test_controlling_hooks.py
index 359df97..96d75b5 100644
--- a/tests/smoke_controlling_hooks.py
+++ b/tests/test_controlling_hooks.py
@@ -20,7 +20,7 @@
Run with:
- .venv/bin/python -m tests.smoke_controlling_hooks
+ .venv/bin/python -m tests.test_controlling_hooks
"""
from __future__ import annotations
@@ -37,8 +37,7 @@
from pyagent import plugins as plugins_mod
from pyagent.agent import Agent
-
-# ---- Test fixture helpers (mirrored from tests/smoke_plugins.py) ----
+# ---- Test fixture helpers (mirrored from tests/test_plugins.py) ----
def _write_plugin(
@@ -54,11 +53,7 @@ def _write_plugin(
) -> Path:
pdir = plugins_root / dirname
pdir.mkdir(parents=True, exist_ok=True)
- tools_line = (
- "tools = ["
- + ", ".join(f'"{t}"' for t in (provides_tools or []))
- + "]"
- )
+ tools_line = "tools = [" + ", ".join(f'"{t}"' for t in (provides_tools or [])) + "]"
sections_line = (
"prompt_sections = ["
+ ", ".join(f'"{s}"' for s in (provides_sections or []))
@@ -68,7 +63,7 @@ def _write_plugin(
manifest = (
f'name = "{name}"\n'
f'version = "0.1.0"\n'
- f'description = "{name} plugin (smoke test)"\n'
+ f'description = "{name} plugin (test)"\n'
f'api_version = "{api_version}"\n\n'
"[provides]\n"
f"{tools_line}\n"
@@ -83,9 +78,7 @@ def _write_plugin(
def _isolated_config_dir():
tmp_cfg = Path(tempfile.mkdtemp(prefix="pyagent-v2hook-cfg-"))
- (tmp_cfg / "config.toml").write_text(
- "built_in_plugins_enabled = []\n"
- )
+ (tmp_cfg / "config.toml").write_text("built_in_plugins_enabled = []\n")
original_config = paths.config_dir
original_data = paths.data_dir
paths.config_dir = lambda: tmp_cfg # type: ignore[assignment]
@@ -148,10 +141,13 @@ def test_allow_no_change() -> None:
)
loaded = plugins_mod.load()
agent = _mk_agent(loaded)
- result = agent._route_tool({
- "id": "1", "name": "widget",
- "args": {"path": "/x", "value": "v"},
- })
+ result = agent._route_tool(
+ {
+ "id": "1",
+ "name": "widget",
+ "args": {"path": "/x", "value": "v"},
+ }
+ )
assert result == "widget(path='/x', value='v')", result
assert _drain_pending(agent) == []
print("✓ allow: hook is observer, tool runs unchanged")
@@ -161,11 +157,11 @@ def test_allow_no_change() -> None:
def test_block_short_circuits_before_permission(caplog=None) -> None:
"""A `block` decision must:
- - prevent the tool from running entirely
- - surface a `<blocked by plugin X: reason>` marker to the model
- - emit an INFO log line with `plugin=`, `tool=`, `reason=`
- - happen BEFORE permission checks (asserted by the tool body
- never running — if it ran, our marker tool would record it)
+ - prevent the tool from running entirely
+ - surface a `<blocked by plugin X: reason>` marker to the model
+ - emit an INFO log line with `plugin=`, `tool=`, `reason=`
+ - happen BEFORE permission checks (asserted by the tool body
+ never running — if it ran, our marker tool would record it)
"""
cfg, restore = _isolated_config_dir()
try:
@@ -212,10 +208,13 @@ def emit(self, record: logging.LogRecord) -> None:
agent_logger.setLevel(logging.INFO)
agent_logger.addHandler(cap)
try:
- result = agent._route_tool({
- "id": "1", "name": "widget",
- "args": {"path": "/x", "value": "v"},
- })
+ result = agent._route_tool(
+ {
+ "id": "1",
+ "name": "widget",
+ "args": {"path": "/x", "value": "v"},
+ }
+ )
finally:
agent_logger.removeHandler(cap)
agent_logger.setLevel(prev_level)
@@ -226,11 +225,10 @@ def emit(self, record: logging.LogRecord) -> None:
"(tool body is also where permission checks live)"
)
# INFO-level structured log line.
- info_msgs = [
- r.getMessage() for r in records if r.levelno == logging.INFO
- ]
+ info_msgs = [r.getMessage() for r in records if r.levelno == logging.INFO]
matched = [
- m for m in info_msgs
+ m
+ for m in info_msgs
if "plugin=blocker" in m
and "tool=widget" in m
and "reason=not allowed in tests" in m
@@ -270,7 +268,8 @@ def test_mutate_args() -> None:
loaded = plugins_mod.load()
agent = _mk_agent(loaded)
call = {
- "id": "1", "name": "widget",
+ "id": "1",
+ "name": "widget",
"args": {"path": "/x", "value": "original"},
}
result = agent._route_tool(call)
@@ -309,13 +308,20 @@ def test_extra_user_message_before_and_after() -> None:
)
loaded = plugins_mod.load()
agent = _mk_agent(loaded)
- agent._route_tool({
- "id": "1", "name": "widget",
- "args": {"path": "/x"},
- })
+ agent._route_tool(
+ {
+ "id": "1",
+ "name": "widget",
+ "args": {"path": "/x"},
+ }
+ )
notes = _drain_pending(agent)
- assert any("[plugin notes notes]: heads up: tool incoming" == n for n in notes), notes
- assert any("[plugin notes notes]: heads up: tool ran" == n for n in notes), notes
+ assert any(
+ n == "[plugin notes notes]: heads up: tool incoming" for n in notes
+ ), notes
+ assert any(
+ n == "[plugin notes notes]: heads up: tool ran" for n in notes
+ ), notes
print(
"✓ extra_user_message from before/after lands on "
"pending_async_replies with [plugin <name> notes]: tag"
@@ -346,10 +352,13 @@ def test_extra_user_message_drains_to_next_turn() -> None:
)
loaded = plugins_mod.load()
agent = _mk_agent(loaded)
- agent._route_tool({
- "id": "1", "name": "widget",
- "args": {"path": "/x"},
- })
+ agent._route_tool(
+ {
+ "id": "1",
+ "name": "widget",
+ "args": {"path": "/x"},
+ }
+ )
# Drain — same machinery `Agent.run` uses at the top of each
# loop iteration.
n = agent._drain_pending_async()
@@ -391,25 +400,31 @@ def test_block_beats_mutate() -> None:
" )\n"
" api.before_tool_call(before)\n"
)
- _write_plugin(cfg / "plugins", dirname="01-a",
- name="block-a", plugin_py=plugin_a)
- _write_plugin(cfg / "plugins", dirname="02-b",
- name="mutate-b", plugin_py=plugin_b)
+ _write_plugin(
+ cfg / "plugins", dirname="01-a", name="block-a", plugin_py=plugin_a
+ )
+ _write_plugin(
+ cfg / "plugins", dirname="02-b", name="mutate-b", plugin_py=plugin_b
+ )
loaded = plugins_mod.load()
agent = _mk_agent(loaded)
- result = agent._route_tool({
- "id": "1", "name": "widget",
- "args": {"path": "/x", "value": "orig"},
- })
+ result = agent._route_tool(
+ {
+ "id": "1",
+ "name": "widget",
+ "args": {"path": "/x", "value": "orig"},
+ }
+ )
assert result == "<blocked by plugin block-a: nope>", result
# Plugin B's hook never ran.
b_mod = next(
- mod for mod_name, mod in sys.modules.items()
+ mod
+ for mod_name, mod in sys.modules.items()
if mod_name.startswith("pyagent_plugin_mutate_b")
)
- assert b_mod.events == [], (
- f"block must short-circuit; B should not have run: {b_mod.events}"
- )
+ assert (
+ b_mod.events == []
+ ), f"block must short-circuit; B should not have run: {b_mod.events}"
print("✓ block > mutate: later mutate hook does not fire")
finally:
restore()
@@ -442,25 +457,31 @@ def test_mutate_chaining() -> None:
" )\n"
" api.before_tool_call(before)\n"
)
- _write_plugin(cfg / "plugins", dirname="01-mA",
- name="mut-a", plugin_py=plugin_a)
- _write_plugin(cfg / "plugins", dirname="02-mB",
- name="mut-b", plugin_py=plugin_b)
+ _write_plugin(
+ cfg / "plugins", dirname="01-mA", name="mut-a", plugin_py=plugin_a
+ )
+ _write_plugin(
+ cfg / "plugins", dirname="02-mB", name="mut-b", plugin_py=plugin_b
+ )
loaded = plugins_mod.load()
agent = _mk_agent(loaded)
- result = agent._route_tool({
- "id": "1", "name": "widget",
- "args": {"path": "/x", "value": "orig"},
- })
+ result = agent._route_tool(
+ {
+ "id": "1",
+ "name": "widget",
+ "args": {"path": "/x", "value": "orig"},
+ }
+ )
assert "A-then-B" in result, result
# Plugin B saw what plugin A returned.
b_mod = next(
- mod for mod_name, mod in sys.modules.items()
+ mod
+ for mod_name, mod in sys.modules.items()
if mod_name.startswith("pyagent_plugin_mut_b")
)
- assert b_mod.seen == ["A"], (
- f"plugin B must see A's mutated value, not 'orig': {b_mod.seen}"
- )
+ assert b_mod.seen == [
+ "A"
+ ], f"plugin B must see A's mutated value, not 'orig': {b_mod.seen}"
print("✓ mutate chains in registration order; later sees earlier's args")
finally:
restore()
@@ -487,19 +508,25 @@ def test_replace_result_chaining() -> None:
" )\n"
" api.after_tool_call(after)\n"
)
- _write_plugin(cfg / "plugins", dirname="01-rA",
- name="rep-a", plugin_py=plugin_a)
- _write_plugin(cfg / "plugins", dirname="02-rB",
- name="rep-b", plugin_py=plugin_b)
+ _write_plugin(
+ cfg / "plugins", dirname="01-rA", name="rep-a", plugin_py=plugin_a
+ )
+ _write_plugin(
+ cfg / "plugins", dirname="02-rB", name="rep-b", plugin_py=plugin_b
+ )
loaded = plugins_mod.load()
agent = _mk_agent(loaded)
- result = agent._route_tool({
- "id": "1", "name": "widget",
- "args": {"path": "/x"},
- })
+ result = agent._route_tool(
+ {
+ "id": "1",
+ "name": "widget",
+ "args": {"path": "/x"},
+ }
+ )
assert result == "A-then-B", result
b_mod = next(
- mod for mod_name, mod in sys.modules.items()
+ mod
+ for mod_name, mod in sys.modules.items()
if mod_name.startswith("pyagent_plugin_rep_b")
)
assert b_mod.seen == ["A"], (
@@ -535,10 +562,13 @@ def test_v1_return_value_ignored() -> None:
)
loaded = plugins_mod.load()
agent = _mk_agent(loaded)
- result = agent._route_tool({
- "id": "1", "name": "widget",
- "args": {"path": "/x", "value": "v"},
- })
+ result = agent._route_tool(
+ {
+ "id": "1",
+ "name": "widget",
+ "args": {"path": "/x", "value": "v"},
+ }
+ )
# Tool ran normally — block was ignored because plugin is v1.
assert "widget(path='/x'" in result, result
assert "<blocked" not in result, result
@@ -558,12 +588,13 @@ def test_strategic_reevaluation_path_keyed() -> None:
)
loaded = plugins_mod.load(is_subagent=False)
names = [s.manifest.name for s in loaded.states]
- assert "strategic-reevaluation" in names, (
- f"expected strategic-reevaluation to load: {names}"
- )
+ assert (
+ "strategic-reevaluation" in names
+ ), f"expected strategic-reevaluation to load: {names}"
# Reset the per-path counter so this run starts clean.
from pyagent.plugins.strategic_reevaluation import _reset_for_tests
+
_reset_for_tests()
agent = _mk_agent(loaded)
@@ -575,27 +606,24 @@ def failing_edit(path: str, **kw: Any) -> str:
agent.add_tool("edit_file", failing_edit, auto_offload=False)
def call_edit(path: str) -> None:
- agent._route_tool({
- "id": f"id-{path}",
- "name": "edit_file",
- "args": {"path": path, "old_string": "x", "new_string": "y"},
- })
+ agent._route_tool(
+ {
+ "id": f"id-{path}",
+ "name": "edit_file",
+ "args": {"path": path, "old_string": "x", "new_string": "y"},
+ }
+ )
# Three consecutive failures on path A → note fires.
call_edit("/a")
call_edit("/a")
notes = _drain_pending(agent)
- assert notes == [], (
- f"only 2 failures yet; should not have fired: {notes}"
- )
+ assert notes == [], f"only 2 failures yet; should not have fired: {notes}"
call_edit("/a")
notes = _drain_pending(agent)
assert any("strategic-reevaluation notes" in n for n in notes), notes
assert any("/a" in n for n in notes), notes
- print(
- "✓ strategic-reevaluation: 3 consecutive fails on path A "
- "→ inject"
- )
+ print("✓ strategic-reevaluation: 3 consecutive fails on path A " "→ inject")
# Reset and try interleaved A/B/A/B/A/B failures → no inject
# (per-path counter; each path tops out at 1 between resets).
@@ -645,6 +673,7 @@ def test_strategic_reevaluation_resets_on_success() -> None:
)
loaded = plugins_mod.load(is_subagent=False)
from pyagent.plugins.strategic_reevaluation import _reset_for_tests
+
_reset_for_tests()
agent = _mk_agent(loaded)
@@ -659,11 +688,13 @@ def edit(path: str, **kw: Any) -> str:
agent.add_tool("edit_file", edit, auto_offload=False)
def call_edit(path: str) -> None:
- agent._route_tool({
- "id": f"id-{path}",
- "name": "edit_file",
- "args": {"path": path, "old_string": "x", "new_string": "y"},
- })
+ agent._route_tool(
+ {
+ "id": f"id-{path}",
+ "name": "edit_file",
+ "args": {"path": path, "old_string": "x", "new_string": "y"},
+ }
+ )
# Two fails, one success, two more fails → counter was reset
# by the success, so we're at 2 again, not 4. No note.
@@ -740,9 +771,11 @@ def test_after_hook_receives_is_error_flag() -> None:
lambda: "<error: simulated failure>",
auto_offload=False,
)
+
# Add a raising tool.
def boom() -> str:
raise RuntimeError("boom")
+
agent.add_tool("boom", boom, auto_offload=False)
agent._route_tool({"id": "1", "name": "widget", "args": {}})
@@ -750,8 +783,7 @@ def boom() -> str:
agent._route_tool({"id": "3", "name": "boom", "args": {}})
mod = next(
- m for n, m in sys.modules.items()
- if n.startswith("pyagent_plugin_errflag")
+ m for n, m in sys.modules.items() if n.startswith("pyagent_plugin_errflag")
)
assert len(mod.calls) == 3, mod.calls
# Success → is_error False.
@@ -791,10 +823,13 @@ def test_replace_result_must_be_string() -> None:
)
loaded = plugins_mod.load()
agent = _mk_agent(loaded)
- result = agent._route_tool({
- "id": "1", "name": "widget",
- "args": {"path": "/x", "value": "v"},
- })
+ result = agent._route_tool(
+ {
+ "id": "1",
+ "name": "widget",
+ "args": {"path": "/x", "value": "v"},
+ }
+ )
# Non-string replace_result was dropped; original tool output
# stands.
assert "widget(path='/x'" in result, result
diff --git a/tests/smoke_ctrlc.py b/tests/test_ctrlc.py
similarity index 95%
rename from tests/smoke_ctrlc.py
rename to tests/test_ctrlc.py
index 7021408..b94cf40 100644
--- a/tests/smoke_ctrlc.py
+++ b/tests/test_ctrlc.py
@@ -16,7 +16,7 @@
Run with:
- .venv/bin/python -m tests.smoke_ctrlc
+ .venv/bin/python -m tests.test_ctrlc
"""
from __future__ import annotations
@@ -85,9 +85,7 @@ def main() -> None:
# Reasonable exit code: 0 (clean exit) is ideal. 130 (128 + SIGINT)
# is acceptable if the shell gave up before our handler ran.
# Anything else suggests a crash.
- assert proc.returncode in (0, 130), (
- f"unexpected exit code {proc.returncode}"
- )
+ assert proc.returncode in (0, 130), f"unexpected exit code {proc.returncode}"
print(f"✓ acceptable exit code: {proc.returncode}")
print("\nALL CHECKS PASSED")
diff --git a/tests/smoke_doc_tools.py b/tests/test_doc_tools.py
similarity index 89%
rename from tests/smoke_doc_tools.py
rename to tests/test_doc_tools.py
index 7e02578..c6ec7f0 100644
--- a/tests/smoke_doc_tools.py
+++ b/tests/test_doc_tools.py
@@ -1,4 +1,4 @@
-"""End-to-end smoke for the doc-tools plugin.
+"""End-to-end test for the doc-tools plugin.
Concerns covered:
@@ -35,7 +35,7 @@
Run with:
- .venv/bin/python -m tests.smoke_doc_tools
+ .venv/bin/python -m tests.test_doc_tools
"""
from __future__ import annotations
@@ -88,9 +88,7 @@ def log(self, level, message):
def _check_register_publishes_both_tools() -> None:
cap = _capture_tools()
- assert set(cap["tools"].keys()) == {"extract_doc", "summarize_doc"}, (
- cap["tools"]
- )
+ assert set(cap["tools"].keys()) == {"extract_doc", "summarize_doc"}, cap["tools"]
print("✓ register() publishes extract_doc + summarize_doc")
@@ -100,9 +98,7 @@ def _check_size_floor_extract() -> None:
cap["plugin_config"] = {"min_size_chars": 1000}
extract = cap["tools"]["extract_doc"]
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write("tiny content " * 5) # ~65 chars
path = f.name
@@ -124,9 +120,7 @@ def _check_size_floor_summarize() -> None:
cap["plugin_config"] = {"min_size_chars": 1000}
summarize = cap["tools"]["summarize_doc"]
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write("tiny" * 10)
path = f.name
permissions.pre_approve(path)
@@ -146,9 +140,7 @@ def _check_max_size_guardrail() -> None:
extract = cap["tools"]["extract_doc"]
body = "X" * (dt_mod._MAX_DOC_CHARS + 1000)
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
path = f.name
permissions.pre_approve(path)
@@ -169,9 +161,7 @@ def _check_extract_invokes_subllm_via_echo_stub() -> None:
extract = cap["tools"]["extract_doc"]
body = "DOCSENTINEL " * 500 # well over the 4KB default floor
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
path = f.name
permissions.pre_approve(path)
@@ -197,9 +187,7 @@ def _check_summarize_invokes_subllm_via_echo_stub() -> None:
summarize = cap["tools"]["summarize_doc"]
body = "SUMMARY-SENTINEL " * 300
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
path = f.name
permissions.pre_approve(path)
@@ -226,9 +214,7 @@ def _check_per_call_model_overrides_config() -> None:
extract = cap["tools"]["extract_doc"]
body = "X" * 8000
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
path = f.name
permissions.pre_approve(path)
@@ -247,17 +233,13 @@ def _check_env_var_overrides_config() -> None:
extract = cap["tools"]["extract_doc"]
body = "X" * 8000
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
path = f.name
permissions.pre_approve(path)
try:
# Env beats config.
- with mock.patch.dict(
- os.environ, {"PYAGENT_DOC_TOOLS_MODEL": "pyagent/echo"}
- ):
+ with mock.patch.dict(os.environ, {"PYAGENT_DOC_TOOLS_MODEL": "pyagent/echo"}):
out = extract(path, "anything")
assert out.startswith("[extracted via pyagent/echo]\n"), out
@@ -283,9 +265,7 @@ def _check_configured_model_is_honored() -> None:
extract = cap["tools"]["extract_doc"]
body = "Y" * 8000
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
path = f.name
permissions.pre_approve(path)
@@ -306,9 +286,7 @@ def _check_input_validation() -> None:
assert extract("", "q") == "<error: path is required>"
assert summarize("") == "<error: path is required>"
# Missing query
- assert extract("/tmp/anything.txt", "").startswith(
- "<error: query is required"
- )
+ assert extract("/tmp/anything.txt", "").startswith("<error: query is required")
# Bad max_chars
out = summarize("/tmp/whatever", max_chars="not-a-number")
assert out.startswith("<error: max_chars must be an integer"), out
@@ -341,9 +319,7 @@ def _check_schema_validation() -> None:
# need a real file to get past the path check; use a body that
# would actually invoke the LLM via the echo stub.
body = "Z" * 8000
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
path = f.name
permissions.pre_approve(path)
@@ -353,7 +329,9 @@ def _check_schema_validation() -> None:
Path(path).unlink()
assert out.startswith("[extracted via pyagent/echo]\n"), out
# Whitespace schema must NOT inject the schema block.
- assert "schema" not in out.lower().split("\n", 1)[1].split("extraction request:")[0], out
+ assert (
+ "schema" not in out.lower().split("\n", 1)[1].split("extraction request:")[0]
+ ), out
print("✓ schema validation: type/length/JSON-parse + empty falls through")
@@ -364,9 +342,7 @@ def _check_decode_error_marker() -> None:
cap["plugin_config"] = {"min_size_chars": 100}
extract = cap["tools"]["extract_doc"]
- with tempfile.NamedTemporaryFile(
- "wb", suffix=".bin", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("wb", suffix=".bin", delete=False) as f:
# Latin-1-only bytes that fail UTF-8 decode.
f.write(b"\xff\xfe\xfd this is not utf-8 \xc3\x28")
path = f.name
@@ -386,10 +362,8 @@ def _check_permission_denied_marker() -> None:
cap = _capture_tools()
extract = cap["tools"]["extract_doc"]
- bogus = "/tmp/__doc_tools_smoke_perm_denied__.txt"
- with mock.patch.object(
- permissions, "require_access", return_value=False
- ):
+ bogus = "/tmp/__doc_tools_test_perm_denied__.txt"
+ with mock.patch.object(permissions, "require_access", return_value=False):
out = extract(bogus, "anything")
assert out == f"<access denied: {bogus}>", out
print("✓ permission denied → <access denied: ...> marker")
@@ -400,7 +374,7 @@ def _check_nonexistent_file_marker() -> None:
cap["plugin_config"] = {"min_size_chars": 100}
extract = cap["tools"]["extract_doc"]
- bogus = "/tmp/__doc_tools_smoke_does_not_exist__.txt"
+ bogus = "/tmp/__doc_tools_test_does_not_exist__.txt"
permissions.pre_approve(bogus)
out = extract(bogus, "anything")
assert out == f"<file not found: {bogus}>", out
@@ -414,9 +388,7 @@ def _check_subllm_failure_wrapped() -> None:
extract = cap["tools"]["extract_doc"]
body = "Z" * 8000
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
path = f.name
permissions.pre_approve(path)
@@ -446,9 +418,7 @@ def _check_subllm_timeout_marker() -> None:
extract = cap["tools"]["extract_doc"]
body = "T" * 8000
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
path = f.name
permissions.pre_approve(path)
@@ -462,9 +432,7 @@ def respond(self, **_kw):
from pyagent import llms
try:
- with mock.patch.object(
- llms, "get_client", return_value=_SlowClient()
- ):
+ with mock.patch.object(llms, "get_client", return_value=_SlowClient()):
t0 = time.time()
out = extract(path, "anything", model="pyagent/echo")
elapsed = time.time() - t0
@@ -531,12 +499,14 @@ def _check_register_warns_on_bogus_cache_size() -> None:
def _check_register_silent_on_valid_config() -> None:
"""A clean config produces zero warnings."""
- cap = _capture_tools(plugin_config={
- "model": "anthropic/claude-haiku-4-5-20251001",
- "timeout_s": 60,
- "cache_size": 32,
- "min_size_chars": 4000,
- })
+ cap = _capture_tools(
+ plugin_config={
+ "model": "anthropic/claude-haiku-4-5-20251001",
+ "timeout_s": 60,
+ "cache_size": 32,
+ "min_size_chars": 4000,
+ }
+ )
msgs = [m for level, m in cap["logs"] if level == "warning"]
assert msgs == [], f"expected no warnings on clean config, got: {msgs}"
@@ -565,9 +535,7 @@ def _check_lru_cache_returns_cached_result() -> None:
extract = cap["tools"]["extract_doc"]
body = "CACHE-SENTINEL " * 500
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
path = f.name
permissions.pre_approve(path)
@@ -589,9 +557,9 @@ def _counted(model):
Path(path).unlink()
assert first == second, (first, second)
- assert call_count["n"] == 1, (
- f"expected 1 sub-LLM call (cache hit on second), got {call_count['n']}"
- )
+ assert (
+ call_count["n"] == 1
+ ), f"expected 1 sub-LLM call (cache hit on second), got {call_count['n']}"
print("✓ cache: identical re-query hits cache (1 call instead of 2)")
@@ -600,9 +568,7 @@ def _check_lru_cache_invalidates_on_file_change() -> None:
cap = _capture_tools()
extract = cap["tools"]["extract_doc"]
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write("ORIGINAL " * 600)
path = f.name
permissions.pre_approve(path)
@@ -639,9 +605,7 @@ def _check_lru_cache_disabled_at_size_zero() -> None:
extract = cap["tools"]["extract_doc"]
body = "DISABLED " * 600
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
path = f.name
permissions.pre_approve(path)
@@ -662,9 +626,9 @@ def _counted(model):
finally:
Path(path).unlink()
- assert call_count["n"] == 2, (
- f"expected 2 sub-LLM calls (cache disabled), got {call_count['n']}"
- )
+ assert (
+ call_count["n"] == 2
+ ), f"expected 2 sub-LLM calls (cache disabled), got {call_count['n']}"
print("✓ cache: cache_size=0 disables, both calls go to LLM")
@@ -677,9 +641,7 @@ def _check_lru_cache_evicts_oldest() -> None:
paths: list[str] = []
body = "LRU " * 1500
for _ in range(3):
- with tempfile.NamedTemporaryFile(
- "w", suffix=".txt", delete=False
- ) as f:
+ with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
f.write(body)
paths.append(f.name)
permissions.pre_approve(paths[-1])
@@ -743,7 +705,7 @@ def main() -> None:
_check_lru_cache_invalidates_on_file_change()
_check_lru_cache_disabled_at_size_zero()
_check_lru_cache_evicts_oldest()
- print("smoke_doc_tools: all checks passed")
+ print("test_doc_tools: all checks passed")
if __name__ == "__main__":
diff --git a/tests/smoke_edit_file.py b/tests/test_edit_file.py
similarity index 96%
rename from tests/smoke_edit_file.py
rename to tests/test_edit_file.py
index 4e0eeec..7a7f962 100644
--- a/tests/smoke_edit_file.py
+++ b/tests/test_edit_file.py
@@ -18,7 +18,7 @@
Run with:
- .venv/bin/python -m tests.smoke_edit_file
+ .venv/bin/python -m tests.test_edit_file
"""
from __future__ import annotations
@@ -31,7 +31,7 @@
def main() -> None:
- tmp = Path(tempfile.mkdtemp(prefix="pyagent-smoke-edit-"))
+ tmp = Path(tempfile.mkdtemp(prefix="pyagent-test-edit-"))
permissions.set_workspace(tmp)
# 1. single-match replace + line number
@@ -105,7 +105,7 @@ def main() -> None:
# 11. workspace gate refusal — path outside the configured workspace.
# Use a sibling tmpdir so the path actually exists but isn't in scope.
- outside = Path(tempfile.mkdtemp(prefix="pyagent-smoke-edit-outside-"))
+ outside = Path(tempfile.mkdtemp(prefix="pyagent-test-edit-outside-"))
outside_file = outside / "scratch.txt"
outside_file.write_text("some content\n")
out = edit_file(str(outside_file), "some", "SOME")
diff --git a/tests/smoke_glob.py b/tests/test_glob.py
similarity index 96%
rename from tests/smoke_glob.py
rename to tests/test_glob.py
index bab1049..c43f94b 100644
--- a/tests/smoke_glob.py
+++ b/tests/test_glob.py
@@ -15,7 +15,7 @@
Run with:
- .venv/bin/python -m tests.smoke_glob
+ .venv/bin/python -m tests.test_glob
"""
from __future__ import annotations
@@ -50,7 +50,7 @@ def _seed(tmp: Path) -> None:
def main() -> None:
- tmp = Path(tempfile.mkdtemp(prefix="pyagent-smoke-glob-")).resolve()
+ tmp = Path(tempfile.mkdtemp(prefix="pyagent-test-glob-")).resolve()
permissions.set_workspace(tmp)
_seed(tmp)
@@ -101,10 +101,10 @@ def main() -> None:
# explicit lexical-order check on a known set).
out = glob("**/*.py", root=str(tmp))
assert out == sorted(out), out
- print(f"✓ sorted output")
+ print("✓ sorted output")
# 6. Permission gate: root outside the workspace.
- outside = Path(tempfile.mkdtemp(prefix="pyagent-smoke-glob-outside-")).resolve()
+ outside = Path(tempfile.mkdtemp(prefix="pyagent-test-glob-outside-")).resolve()
(outside / "leaked.py").write_text("x")
out = glob("*.py", root=str(outside))
assert len(out) == 1, out
diff --git a/tests/smoke_grep.py b/tests/test_grep.py
similarity index 86%
rename from tests/smoke_grep.py
rename to tests/test_grep.py
index f50a683..94d65cb 100644
--- a/tests/smoke_grep.py
+++ b/tests/test_grep.py
@@ -18,7 +18,7 @@
Run with:
- .venv/bin/python -m tests.smoke_grep
+ .venv/bin/python -m tests.test_grep
"""
from __future__ import annotations
@@ -29,7 +29,6 @@
from pyagent import permissions
from pyagent.tools import grep
-
SAMPLE = """\
line 1
line 2
@@ -53,7 +52,7 @@ def _seed(tmp: Path) -> Path:
def main() -> None:
- tmp = Path(tempfile.mkdtemp(prefix="pyagent-smoke-grep-")).resolve()
+ tmp = Path(tempfile.mkdtemp(prefix="pyagent-test-grep-")).resolve()
permissions.set_workspace(tmp)
f = _seed(tmp)
fp = str(f)
@@ -67,7 +66,7 @@ def main() -> None:
out = grep(r"return 42", fp, before=2)
assert out == [
f"{fp}:3-def helper():",
- f"{fp}:4- \"\"\"Compute the answer.\"\"\"",
+ f'{fp}:4- """Compute the answer."""',
f"{fp}:5: return 42",
], out
print(f"[ok] before=2: {out}")
@@ -87,18 +86,18 @@ def main() -> None:
assert out_ctx == out_ba, (out_ctx, out_ba)
assert out_ctx == [
f"{fp}:3-def helper():",
- f"{fp}:4- \"\"\"Compute the answer.\"\"\"",
+ f'{fp}:4- """Compute the answer."""',
f"{fp}:5: return 42",
f"{fp}:6-line 6",
f"{fp}:7-line 7",
], out_ctx
- print(f"[ok] context=2 equals before=2,after=2")
+ print("[ok] context=2 equals before=2,after=2")
# 5. Explicit before wins over context. context=2, before=1 →
# 1 leading line, 2 trailing lines.
out = grep(r"return 42", fp, context=2, before=1)
assert out == [
- f"{fp}:4- \"\"\"Compute the answer.\"\"\"",
+ f'{fp}:4- """Compute the answer."""',
f"{fp}:5: return 42",
f"{fp}:6-line 6",
f"{fp}:7-line 7",
@@ -115,7 +114,7 @@ def main() -> None:
assert out == [f"{ep}:1:alpha", f"{ep}:2-beta"], out
out = grep(r"gamma", ep, before=1, after=5)
assert out == [f"{ep}:2-beta", f"{ep}:3:gamma"], out
- print(f"[ok] context truncates at file boundaries")
+ print("[ok] context truncates at file boundaries")
# 7. Adjacent matches collapse: pattern hits both `return 42`
# (line 5) and `return 99` (line 9). With context=2, windows
@@ -124,7 +123,7 @@ def main() -> None:
out = grep(r"return", fp, context=2)
assert out == [
f"{fp}:3-def helper():",
- f"{fp}:4- \"\"\"Compute the answer.\"\"\"",
+ f'{fp}:4- """Compute the answer."""',
f"{fp}:5: return 42",
f"{fp}:6-line 6",
f"{fp}:7-line 7",
@@ -136,19 +135,19 @@ def main() -> None:
assert "--" not in out, out
# Sanity: each line appears at most once.
assert len(out) == len(set(out)), out
- print(f"[ok] adjacent matches collapse without duplication")
+ print("[ok] adjacent matches collapse without duplication")
# 7b. Non-adjacent matches keep the `--` separator. context=0,
# before=1: window [4..5] then [8..9] don't touch.
out = grep(r"return", fp, before=1)
assert out == [
- f"{fp}:4- \"\"\"Compute the answer.\"\"\"",
+ f'{fp}:4- """Compute the answer."""',
f"{fp}:5: return 42",
"--",
f"{fp}:8-def other():",
f"{fp}:9: return 99",
], out
- print(f"[ok] non-adjacent matches separated by --")
+ print("[ok] non-adjacent matches separated by --")
# 8. Multiple files: hits in different files are emitted in
# alphabetical path order, each file's groups separated by `--`
@@ -166,7 +165,7 @@ def main() -> None:
f"{op}:1-hello world",
f"{op}:2:return 7",
f"{op}:3-bye",
- f"{fp}:4- \"\"\"Compute the answer.\"\"\"",
+ f'{fp}:4- """Compute the answer."""',
f"{fp}:5: return 42",
f"{fp}:6-line 6",
"--",
@@ -175,7 +174,7 @@ def main() -> None:
f"{fp}:10-line 10",
]
assert out == expected, out
- print(f"[ok] multiple files emit `--` between groups")
+ print("[ok] multiple files emit `--` between groups")
# 8b. Same multi-file search without context: no `--` lines at
# all, plain colon separator throughout, sorted by file then
@@ -187,11 +186,13 @@ def main() -> None:
f"{fp}:9: return 99",
], out
assert "--" not in out, out
- print(f"[ok] no-context multi-file output stays flat")
+ print("[ok] no-context multi-file output stays flat")
# 9. Bad input: negative integer / non-coercible string.
out = grep(r"return", fp, before=-1)
- assert len(out) == 1 and out[0].startswith("<error:") and "non-negative" in out[0], out
+ assert (
+ len(out) == 1 and out[0].startswith("<error:") and "non-negative" in out[0]
+ ), out
print(f"[ok] negative before: {out[0]!r}")
out = grep(r"return", fp, context=-3)
@@ -206,10 +207,10 @@ def main() -> None:
out = grep(r"return 42", fp, before="2") # type: ignore[arg-type]
assert out == [
f"{fp}:3-def helper():",
- f"{fp}:4- \"\"\"Compute the answer.\"\"\"",
+ f'{fp}:4- """Compute the answer."""',
f"{fp}:5: return 42",
], out
- print(f"[ok] string coerces to int")
+ print("[ok] string coerces to int")
print("\nALL CHECKS PASSED")
diff --git a/tests/smoke_hn_search.py b/tests/test_hn_search.py
similarity index 93%
rename from tests/smoke_hn_search.py
rename to tests/test_hn_search.py
index 560d08a..4029bf1 100644
--- a/tests/smoke_hn_search.py
+++ b/tests/test_hn_search.py
@@ -1,4 +1,4 @@
-"""End-to-end smoke for the hn-search plugin.
+"""End-to-end test for the hn-search plugin.
Concerns covered:
@@ -28,7 +28,7 @@
`save_structured` config; silent on clean config.
Run with:
- .venv/bin/python -m tests.smoke_hn_search
+ .venv/bin/python -m tests.test_hn_search
"""
from __future__ import annotations
@@ -62,7 +62,7 @@ class _FakeAPI:
def plugin_config(self):
return captured["plugin_config"]
- def register_tool(self, name, fn):
+ def register_tool(self, name, fn, *, role_only=False):
captured["tools"][name] = fn
def log(self, level, message):
@@ -104,15 +104,15 @@ def log(self, level, message):
def _check_plugin_loads_under_default_config() -> None:
- tmp = Path(tempfile.mkdtemp(prefix="pyagent-smoke-hn-"))
+ tmp = Path(tempfile.mkdtemp(prefix="pyagent-test-hn-"))
with mock.patch.object(paths_mod, "config_dir", return_value=tmp):
with mock.patch.object(
plugins, "LOCAL_PLUGINS_DIR", Path(tmp / "no_local_plugins")
):
cfg = config_mod.load()
- assert "hn-search" in cfg["built_in_plugins_enabled"], (
- cfg["built_in_plugins_enabled"]
- )
+ assert "hn-search" in cfg["built_in_plugins_enabled"], cfg[
+ "built_in_plugins_enabled"
+ ]
loaded = plugins.load()
tool_names = set(loaded.tools().keys())
assert "hn_search" in tool_names, tool_names
@@ -160,7 +160,9 @@ def _check_parse_hits_tolerates_weird_payloads() -> None:
}
stories = _parse_hits(payload)
assert len(stories) == 1, stories
- assert stories[0].permalink == "https://news.ycombinator.com/item?id=777", stories[0]
+ assert stories[0].permalink == "https://news.ycombinator.com/item?id=777", stories[
+ 0
+ ]
assert stories[0].points == 0, stories[0]
assert stories[0].num_comments == 0, stories[0]
assert stories[0].type == "comment", stories[0]
@@ -170,7 +172,7 @@ def _check_parse_hits_tolerates_weird_payloads() -> None:
def _check_parse_hits_type_tag_precedence() -> None:
"""Lock the chosen precedence on `_tags = [story, ask_hn, ...]`.
The first non-author/non-id tag wins — currently `story` over
- `ask_hn`. If that flips, the smoke fails loudly and the reviewer
+ `ask_hn`. If that flips, the test fails loudly and the reviewer
can decide whether the new precedence is intentional."""
payload = {
"hits": [
@@ -204,7 +206,11 @@ def _check_parse_hits_type_tag_precedence() -> None:
def _check_url_builder() -> None:
url = _build_url(
- "postgres sqlite", n=10, kind="story", time_window="all", min_points=None,
+ "postgres sqlite",
+ n=10,
+ kind="story",
+ time_window="all",
+ min_points=None,
)
assert url.startswith("https://hn.algolia.com/api/v1/search?"), url
assert "query=postgres+sqlite" in url or "query=postgres%20sqlite" in url, url
@@ -243,8 +249,14 @@ def _check_time_window_filter_helper() -> None:
assert hn_mod._time_window_filter("hour") == f"created_at_i>{fake_now - 3600}"
assert hn_mod._time_window_filter("day") == f"created_at_i>{fake_now - 86400}"
assert hn_mod._time_window_filter("week") == f"created_at_i>{fake_now - 604800}"
- assert hn_mod._time_window_filter("month") == f"created_at_i>{fake_now - 2_592_000}"
- assert hn_mod._time_window_filter("year") == f"created_at_i>{fake_now - 31_536_000}"
+ assert (
+ hn_mod._time_window_filter("month")
+ == f"created_at_i>{fake_now - 2_592_000}"
+ )
+ assert (
+ hn_mod._time_window_filter("year")
+ == f"created_at_i>{fake_now - 31_536_000}"
+ )
# Unknown window → empty (defensive; the tool layer validates first)
assert hn_mod._time_window_filter("century") == ""
print("✓ time_window: produces literal numeric epochs Algolia accepts")
@@ -257,9 +269,7 @@ def _check_tool_returns_attachment() -> None:
hn_search = cap["tools"]["hn_search"]
fixture_stories = _parse_hits(_FIXTURE_HITS_PAYLOAD)
- with mock.patch.object(
- hn_mod, "hn_text_search", return_value=fixture_stories
- ) as m:
+ with mock.patch.object(hn_mod, "hn_text_search", return_value=fixture_stories) as m:
out = hn_search("postgres sqlite", n=2, kind="story")
args, kwargs = m.call_args
@@ -369,10 +379,12 @@ def _check_register_warnings() -> None:
assert any("save_structured must be a bool" in m for m in msgs), msgs
# Clean config: silent.
- cap = _make_fake_api(plugin_config={
- "timeout_s": 15,
- "save_structured": True,
- })
+ cap = _make_fake_api(
+ plugin_config={
+ "timeout_s": 15,
+ "save_structured": True,
+ }
+ )
msgs = [m for level, m in cap["logs"] if level == "warning"]
assert msgs == [], msgs
print("✓ register-time warnings: bogus configs flagged, clean config silent")
@@ -392,7 +404,7 @@ def main() -> None:
_check_validation_paths()
_check_http_failures_translate()
_check_register_warnings()
- print("smoke_hn_search: all checks passed")
+ print("test_hn_search: all checks passed")
if __name__ == "__main__":
diff --git a/tests/smoke_html_tools.py b/tests/test_html_tools.py
similarity index 86%
rename from tests/smoke_html_tools.py
rename to tests/test_html_tools.py
index 737dc19..8c4e93c 100644
--- a/tests/smoke_html_tools.py
+++ b/tests/test_html_tools.py
@@ -1,4 +1,4 @@
-"""End-to-end smoke for the html-tools plugin and the restructured
+"""End-to-end test for the html-tools plugin and the restructured
fetch_url.
Three concerns:
@@ -21,7 +21,7 @@
Run with:
- .venv/bin/python -m tests.smoke_html_tools
+ .venv/bin/python -m tests.test_html_tools
"""
from __future__ import annotations
@@ -34,7 +34,6 @@
from pyagent.plugins.html_tools import extraction
from pyagent.session import Attachment
-
_NEWS_HTML = """
<!doctype html>
<html><head><title>headline
@@ -74,7 +73,7 @@ def _check_extraction_main_content() -> None:
assert "[link](https://example.com)" in md, md
# List survives as bullets.
assert "- one" in md or "* one" in md, md
- print(f"✓ extraction.main_content drops boilerplate, keeps structure")
+ print("✓ extraction.main_content drops boilerplate, keeps structure")
def _check_extraction_full_document() -> None:
@@ -82,7 +81,7 @@ def _check_extraction_full_document() -> None:
# With main_content=False, boilerplate stays.
assert "home / about / contact" in md or "home" in md, md
assert "The Real Story" in md, md
- print(f"✓ extraction.main_content=False preserves the whole document")
+ print("✓ extraction.main_content=False preserves the whole document")
def _check_extraction_select_table() -> None:
@@ -100,9 +99,7 @@ def _check_extraction_select_table() -> None:
def _check_extraction_select_limit() -> None:
- md, total, returned = extraction.html_select_to_markdown(
- _TABLE_HTML, "tr", limit=2
- )
+ md, total, returned = extraction.html_select_to_markdown(_TABLE_HTML, "tr", limit=2)
assert total == 3, total
assert returned == 2, returned
print(f"✓ extraction.select honors limit (matched {total}, kept {returned})")
@@ -111,7 +108,7 @@ def _check_extraction_select_limit() -> None:
def _check_plugin_loads_under_default_config() -> None:
"""With the default config, html-tools is in built_in_plugins_enabled
and load() exposes both tools."""
- tmp = Path(tempfile.mkdtemp(prefix="pyagent-smoke-htmltools-"))
+ tmp = Path(tempfile.mkdtemp(prefix="pyagent-test-htmltools-"))
# Point config_dir at an empty temp dir so user/project config can't
# mask the bundled defaults (e.g. an existing user config that hasn't
# added "html-tools" yet).
@@ -120,9 +117,9 @@ def _check_plugin_loads_under_default_config() -> None:
plugins, "LOCAL_PLUGINS_DIR", Path(tmp / "no_local_plugins")
):
cfg = config_mod.load()
- assert "html-tools" in cfg["built_in_plugins_enabled"], (
- cfg["built_in_plugins_enabled"]
- )
+ assert "html-tools" in cfg["built_in_plugins_enabled"], cfg[
+ "built_in_plugins_enabled"
+ ]
loaded = plugins.load()
tool_names = set(loaded.tools().keys())
assert "html_select" in tool_names, tool_names
@@ -161,7 +158,7 @@ def _check_fetch_url_md_default() -> None:
assert "[link](https://example.com)" in result.preview, result.preview
# Boilerplate must not survive the main-content extraction.
assert "home / about / contact" not in result.preview, result.preview
- print(f"✓ fetch_url(format='md') saves raw + inlines markdown")
+ print("✓ fetch_url(format='md') saves raw + inlines markdown")
def _check_fetch_url_void() -> None:
@@ -169,16 +166,14 @@ def _check_fetch_url_void() -> None:
with mock.patch.object(
tools.requests, "get", return_value=_FakeResponse(_NEWS_HTML)
):
- result = tools.fetch_url(
- "https://example.com/x", format="void"
- )
+ result = tools.fetch_url("https://example.com/x", format="void")
assert isinstance(result, Attachment), type(result)
assert result.content == _NEWS_HTML, "raw still saved"
- assert "format=\"void\"" in result.preview, result.preview
+ assert 'format="void"' in result.preview, result.preview
# Markdown body must NOT appear in preview.
assert "The Real Story" not in result.preview, result.preview
assert "[link]" not in result.preview, result.preview
- print(f"✓ fetch_url(format='void') saves raw, omits markdown body")
+ print("✓ fetch_url(format='void') saves raw, omits markdown body")
def _check_fetch_url_non_html() -> None:
@@ -187,9 +182,7 @@ def _check_fetch_url_non_html() -> None:
with mock.patch.object(
tools.requests,
"get",
- return_value=_FakeResponse(
- body, content_type="application/json"
- ),
+ return_value=_FakeResponse(body, content_type="application/json"),
):
result = tools.fetch_url("https://api.example.com/x")
assert isinstance(result, Attachment), type(result)
@@ -197,7 +190,7 @@ def _check_fetch_url_non_html() -> None:
assert result.suffix == ".json", result.suffix
assert "application/json" in result.preview, result.preview
assert "Non-HTML" in result.preview, result.preview
- print(f"✓ fetch_url skips conversion for non-HTML responses")
+ print("✓ fetch_url skips conversion for non-HTML responses")
def _check_fetch_url_large_md_truncates() -> None:
@@ -208,16 +201,14 @@ def _check_fetch_url_large_md_truncates() -> None:
+ "".join(f"line {i} " + "x " * 200 + "
" for i in range(60))
+ "