devsper 2.1.6__py3-none-any.whl

devsper/knowledge/knowledge_graph.py

@@ -0,0 +1,184 @@
+"""
+Knowledge graph: build relationships between stored memory.
+
+Nodes: documents, concepts, datasets, methods.
+Edges: mentions, cites, related_to, uses, extends, outperforms, constrains, blocks.
+Uses networkx. v1.8: add_or_update_node, add_edge, save/load for extraction.
+"""
+
+import json
+import os
+import re
+from typing import Any
+
+import networkx as nx
+
+from devsper.memory.memory_store import MemoryStore, get_default_store
+from devsper.memory.memory_types import MemoryRecord, MemoryType
+
+
+NODE_DOCUMENT = "document"
+NODE_CONCEPT = "concept"
+NODE_DATASET = "dataset"
+NODE_METHOD = "method"
+
+EDGE_MENTIONS = "mentions"
+EDGE_CITES = "cites"
+EDGE_RELATED_TO = "related_to"
+EDGE_USES = "uses"
+EDGE_EXTENDS = "extends"
+EDGE_OUTPERFORMS = "outperforms"
+EDGE_CONSTRAINS = "constrains"
+EDGE_BLOCKS = "blocks"
+
+
+def _extract_concepts(text: str, limit: int = 15) -> list[str]:
+    """Heuristic: extract likely concepts (title-case phrases, known tokens)."""
+    concepts = set()
+    for m in re.finditer(r"\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b", text):
+        concepts.add(m.group(1).strip())
+    tokens = re.findall(r"\b(diffusion|transformer|dataset|model|training|evaluation|baseline|embedding|neural)\b", text.lower())
+    concepts.update(tokens)
+    return list(concepts)[:limit]
+
+
+def _extract_datasets(text: str, limit: int = 5) -> list[str]:
+    """Heuristic: extract dataset-like names (e.g. MNIST, ImageNet)."""
+    datasets = set()
+    for m in re.finditer(r"\b([A-Z][A-Za-z0-9\-]+(?:-\d+)?)\b", text):
+        w = m.group(1)
+        if len(w) >= 3 and w not in ("The", "This", "These", "When", "What"):
+            datasets.add(w)
+    return list(datasets)[:limit]
+
+
+def _extract_methods(text: str, limit: int = 5) -> list[str]:
+    """Heuristic: method-like phrases (e.g. 'X method', 'Y approach')."""
+    methods = set()
+    for m in re.finditer(r"(\w+(?:\s+\w+)?)\s+(?:method|approach|algorithm|framework)\b", text, re.IGNORECASE):
+        methods.add(m.group(1).strip())
+    return list(methods)[:limit]
+
+
+class KnowledgeGraph:
+    """
+    Build and query a graph over memory: nodes are documents/concepts/datasets/methods,
+    edges are mentions, cites, related_to.
+    """
+
+    def __init__(self, store: MemoryStore | None = None) -> None:
+        self.store = store or get_default_store()
+        self._graph: nx.MultiDiGraph = nx.MultiDiGraph()
+
+    def build_from_memory(self, merge: bool = False) -> nx.MultiDiGraph:
+        """
+        Build graph from all stored memory. Returns the graph.
+        Nodes: document:<id>, concept:<name>, dataset:<name>, method:<name>.
+        Edges: document --mentions--> concept/dataset/method; concept --related_to--> concept.
+        If merge=True, add to existing graph instead of clearing (e.g. after load()).
+        """
+        if not merge:
+            self._graph = nx.MultiDiGraph()
+        records = self.store.list_memory(limit=2000)
+        for r in records:
+            doc_id = f"document:{r.id}"
+            self._graph.add_node(doc_id, kind=NODE_DOCUMENT, memory_id=r.id, label=r.content[:200])
+            for c in _extract_concepts(r.content):
+                node = f"concept:{c}"
+                self._graph.add_node(node, kind=NODE_CONCEPT, label=c)
+                self._graph.add_edge(doc_id, node, type=EDGE_MENTIONS)
+            for d in _extract_datasets(r.content):
+                node = f"dataset:{d}"
+                self._graph.add_node(node, kind=NODE_DATASET, label=d)
+                self._graph.add_edge(doc_id, node, type=EDGE_MENTIONS)
+            for m in _extract_methods(r.content):
+                node = f"method:{m}"
+                self._graph.add_node(node, kind=NODE_METHOD, label=m)
+                self._graph.add_edge(doc_id, node, type=EDGE_MENTIONS)
+        doc_nodes = [n for n, attrs in self._graph.nodes(data=True) if attrs.get("kind") == NODE_DOCUMENT]
+        for doc in doc_nodes:
+            succs = list(self._graph.successors(doc))
+            concepts = [s for s in succs if s.startswith("concept:")]
+            for i, a in enumerate(concepts):
+                for b in concepts[i + 1 :]:
+                    self._graph.add_edge(a, b, type=EDGE_RELATED_TO)
+                    self._graph.add_edge(b, a, type=EDGE_RELATED_TO)
+        return self._graph
+
+    @property
+    def graph(self) -> nx.MultiDiGraph:
+        """Return the current graph (build first with build_from_memory if needed)."""
+        return self._graph
+
+    def get_neighbors(self, node_id: str, edge_type: str | None = None) -> list[tuple[str, str]]:
+        """Return list of (neighbor_id, edge_type) for outgoing edges."""
+        if node_id not in self._graph:
+            return []
+        out = []
+        for _, v, data in self._graph.out_edges(node_id, data=True):
+            et = data.get("type", "")
+            if edge_type is None or et == edge_type:
+                out.append((v, et))
+        return out
+
+    def get_documents_mentioning(self, concept_or_dataset: str) -> list[str]:
+        """Return memory ids of documents that mention the given concept or dataset."""
+        node = f"concept:{concept_or_dataset}"
+        if node not in self._graph:
+            node = f"dataset:{concept_or_dataset}"
+        if node not in self._graph:
+            return []
+        doc_ids = []
+        for pred in self._graph.predecessors(node):
+            if pred.startswith("document:"):
+                doc_ids.append(self._graph.nodes[pred].get("memory_id", pred.replace("document:", "")))
+        return doc_ids
+
+    def add_or_update_node(self, node_id: str, kind: str, label: str, **attrs: Any) -> None:
+        """v1.8: Add or update a node (e.g. from KnowledgeExtractor)."""
+        self._graph.add_node(node_id, kind=kind, label=label, **attrs)
+
+    def add_edge(self, from_id: str, to_id: str, edge_type: str) -> None:
+        """v1.8: Add a directed edge (e.g. from KnowledgeExtractor)."""
+        self._graph.add_node(from_id, **self._graph.nodes.get(from_id, {}))
+        self._graph.add_node(to_id, **self._graph.nodes.get(to_id, {}))
+        self._graph.add_edge(from_id, to_id, type=edge_type)
+
+    def _persist_path(self) -> str:
+        """Path to persisted graph JSON (data_dir/knowledge_graph.json)."""
+        try:
+            from devsper.config import get_config
+            base = get_config().data_dir
+        except Exception:
+            base = os.environ.get("DEVSPER_DATA_DIR", ".devsper")
+        os.makedirs(base, exist_ok=True)
+        return os.path.join(base, "knowledge_graph.json")
+
+    def save(self) -> None:
+        """v1.8: Persist graph to JSON (nodes and edges only; no embeddings)."""
+        nodes = []
+        for nid, data in self._graph.nodes(data=True):
+            nodes.append({"id": nid, **{k: v for k, v in data.items() if isinstance(v, (str, int, float, bool))}})
+        edges = []
+        for u, v, data in self._graph.edges(data=True):
+            edges.append({"from": u, "to": v, "type": data.get("type", "related_to")})
+        payload = {"nodes": nodes, "edges": edges}
+        with open(self._persist_path(), "w", encoding="utf-8") as f:
+            json.dump(payload, f, indent=0)
+
+    def load(self) -> bool:
+        """v1.8: Load graph from JSON if file exists; merge into _graph. Returns True if loaded."""
+        path = self._persist_path()
+        if not os.path.isfile(path):
+            return False
+        with open(path, "r", encoding="utf-8") as f:
+            payload = json.load(f)
+        for n in payload.get("nodes", []):
+            nid = n.pop("id", None)
+            if nid:
+                self._graph.add_node(nid, **n)
+        for e in payload.get("edges", []):
+            u, v = e.get("from"), e.get("to")
+            if u and v:
+                self._graph.add_edge(u, v, type=e.get("type", "related_to"))
+        return True

devsper/knowledge/query.py

@@ -0,0 +1,285 @@
+"""
+Knowledge graph query: entity search and relationship traversal.
+v1.8: query_for_planning for knowledge-guided planning.
+"""
+
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+
+from devsper.knowledge.knowledge_graph import (
+    KnowledgeGraph,
+    NODE_DOCUMENT,
+    NODE_CONCEPT,
+    NODE_DATASET,
+    NODE_METHOD,
+)
+
+
+@dataclass
+class QueryResult:
+    """Structured result: entities matching query and edges (optionally traversed)."""
+
+    entities: list[tuple[str, str]]  # (node_id, label)
+    edges: list[tuple[str, str, str]]  # (from_id, to_id, edge_type)
+    documents: list[str]  # memory ids of documents mentioning matched entities
+
+
+@dataclass
+class PlanningContext:
+    """v1.8: Context from KG for planner injection."""
+
+    relevant_concepts: list[str]
+    prior_findings: list[str]
+    known_constraints: list[str]
+    related_methods: list[str]
+    confidence: float
+
+
+def _node_matches_label(node_id: str, label: str, query_lower: str) -> bool:
+    """True if node label or id contains query terms."""
+    if not label:
+        return False
+    return query_lower in label.lower() or query_lower in node_id.lower()
+
+
+def entity_search(kg: KnowledgeGraph, query_text: str) -> list[tuple[str, str]]:
+    """
+    Find nodes (concept, dataset, method) whose label matches the query.
+    Returns list of (node_id, label).
+    """
+    query_lower = (query_text or "").strip().lower()
+    if not query_lower:
+        return []
+    g = kg.graph
+    matches: list[tuple[str, str]] = []
+    for node_id, data in g.nodes(data=True):
+        kind = data.get("kind")
+        if kind in (NODE_DOCUMENT,):
+            continue
+        label = data.get("label", "") or node_id.split(":", 1)[-1] if ":" in node_id else node_id
+        if _node_matches_label(node_id, label, query_lower):
+            matches.append((node_id, label))
+    return matches
+
+
+def traverse(
+    kg: KnowledgeGraph,
+    node_ids: list[str],
+    hops: int = 1,
+    edge_type: str | None = None,
+) -> list[tuple[str, str, str]]:
+    """
+    Traverse from given nodes up to `hops` steps. Returns list of (from_id, to_id, edge_type).
+    """
+    if hops < 1:
+        return []
+    g = kg.graph
+    edges: list[tuple[str, str, str]] = []
+    frontier = set(node_ids)
+    seen_edges: set[tuple[str, str]] = set()
+    for _ in range(hops):
+        next_frontier = set()
+        for n in frontier:
+            if n not in g:
+                continue
+            for _, v, data in g.out_edges(n, data=True):
+                et = data.get("type", "")
+                if edge_type is not None and et != edge_type:
+                    continue
+                key = (n, v)
+                if key not in seen_edges:
+                    seen_edges.add(key)
+                    edges.append((n, v, et))
+                next_frontier.add(v)
+        frontier = next_frontier
+    return edges
+
+
+def query(
+    kg: KnowledgeGraph,
+    query_text: str,
+    traverse_hops: int = 1,
+) -> QueryResult:
+    """
+    Run entity search for query_text, optionally traverse relationships (1-2 hops).
+    Returns QueryResult with entities, edges, and document ids.
+    """
+    entities = entity_search(kg, query_text)
+    node_ids = [e[0] for e in entities]
+    edges = traverse(kg, node_ids, hops=traverse_hops) if node_ids else []
+    documents: list[str] = []
+    for nid, _ in entities:
+        if nid.startswith("document:"):
+            continue
+        concept_or_dataset = nid.split(":", 1)[-1] if ":" in nid else nid
+        docs = kg.get_documents_mentioning(concept_or_dataset)
+        documents.extend(docs)
+    documents = list(dict.fromkeys(documents))
+    return QueryResult(entities=entities, edges=edges, documents=documents)
+
+
+# Stopwords for task term extraction (simple heuristic)
+_PLANNING_STOPWORDS = frozenset(
+    {
+        "a", "an", "the", "and", "or", "but", "in", "on", "at", "to", "for",
+        "of", "with", "by", "from", "as", "is", "was", "are", "were", "be",
+        "been", "being", "have", "has", "had", "do", "does", "did", "will",
+        "would", "could", "should", "may", "might", "must", "can", "this",
+        "that", "these", "those", "it", "its", "into", "through", "during",
+    }
+)
+
+
+def _extract_candidate_terms(task_description: str) -> list[str]:
+    """Extract candidate terms: split on spaces, drop stopwords, keep capitalized or domain-like."""
+    if not task_description or not task_description.strip():
+        return []
+    words = task_description.strip().split()
+    candidates = []
+    for w in words:
+        w_clean = w.strip(".,;:!?").lower()
+        if not w_clean or w_clean in _PLANNING_STOPWORDS:
+            continue
+        if w[0].isupper() or any(c.isdigit() for c in w) or "_" in w:
+            candidates.append(w_clean)
+        else:
+            candidates.append(w_clean)
+    return list(dict.fromkeys(candidates))
+
+
+def _fuzzy_match_label(term: str, label: str, threshold: float = 0.8) -> float:
+    """Return similarity ratio in [0, 1]; 0 if below threshold."""
+    if not label:
+        return 0.0
+    label_lower = label.lower()
+    term_lower = term.lower()
+    if term_lower in label_lower:
+        return min(1.0, 0.8 + 0.2 * (len(term_lower) / max(1, len(label_lower))))
+    r = SequenceMatcher(None, term_lower, label_lower).ratio()
+    return r if r >= threshold else 0.0
+
+
+def query_for_planning(kg: KnowledgeGraph, task_description: str) -> PlanningContext:
+    """
+    Build planning context from KG: concepts, findings, constraints, methods.
+    Uses term extraction, fuzzy node match, 2-hop neighborhood, centrality + match scoring.
+    """
+    concepts: list[str] = []
+    findings: list[str] = []
+    constraints: list[str] = []
+    methods: list[str] = []
+    g = kg.graph
+    if g.number_of_nodes() == 0:
+        return PlanningContext(
+            relevant_concepts=[],
+            prior_findings=[],
+            known_constraints=[],
+            related_methods=[],
+            confidence=0.0,
+        )
+
+    terms = _extract_candidate_terms(task_description)
+    matched_nodes: list[tuple[str, str, float]] = []  # (node_id, label, match_score)
+    for node_id, data in g.nodes(data=True):
+        kind = data.get("kind")
+        if kind == NODE_DOCUMENT:
+            continue
+        label = data.get("label", "") or (node_id.split(":", 1)[-1] if ":" in node_id else node_id)
+        for t in terms:
+            score = _fuzzy_match_label(t, label, 0.8)
+            if score > 0:
+                matched_nodes.append((node_id, label, score))
+                break
+
+    if not matched_nodes:
+        return PlanningContext(
+            relevant_concepts=[],
+            prior_findings=[],
+            known_constraints=[],
+            related_methods=[],
+            confidence=0.0,
+        )
+
+    neighborhood = set(n[0] for n in matched_nodes)
+    for _ in range(2):
+        next_n = set()
+        for nid in neighborhood:
+            if nid not in g:
+                continue
+            for _, v, _ in g.out_edges(nid, data=True):
+                next_n.add(v)
+            for u, _, _ in g.in_edges(nid, data=True):
+                next_n.add(u)
+        neighborhood |= next_n
+
+    match_scores: dict[str, float] = {}
+    for nid, label, s in matched_nodes:
+        match_scores[nid] = max(match_scores.get(nid, 0), s)
+    try:
+        degree = dict(g.degree(neighborhood))
+    except Exception:
+        degree = {n: 0 for n in neighborhood}
+    scores: list[tuple[str, str, str, float]] = []
+    for nid in neighborhood:
+        data = g.nodes.get(nid, {})
+        kind = data.get("kind", "")
+        label = data.get("label", "") or (nid.split(":", 1)[-1] if ":" in nid else nid)
+        deg = degree.get(nid, 0)
+        recency = 1.0
+        ms = match_scores.get(nid, 0.5)
+        total = (deg * 0.3) + (recency * 0.2) + (ms * 0.5)
+        scores.append((nid, kind, label, total))
+
+    scores.sort(key=lambda x: -x[3])
+    top = scores[:30]
+    for nid, kind, label, _ in top:
+        if kind == NODE_CONCEPT and label not in concepts:
+            concepts.append(label)
+        elif kind == NODE_METHOD and label not in methods:
+            methods.append(label)
+
+    for u, v, data in g.out_edges(neighborhood, data=True):
+        if data.get("type") in ("constrains", "blocks"):
+            edge_desc = f"{u.split(':', 1)[-1] if ':' in u else u} -> {v.split(':', 1)[-1] if ':' in v else v}"
+            if edge_desc not in constraints:
+                constraints.append(edge_desc)
+
+    doc_nodes = [n for n in neighborhood if g.nodes.get(n, {}).get("kind") == NODE_DOCUMENT]
+    for d in doc_nodes[:5]:
+        summary = (g.nodes[d].get("label", "") or d)[:200]
+        if summary and summary not in findings:
+            findings.append(summary)
+
+    total_nodes = g.number_of_nodes()
+    found = len(concepts) + len(methods) + len(findings) + len(constraints)
+    confidence = min(1.0, (found / max(1, total_nodes)) * 2.0) if total_nodes else 0.0
+    confidence = max(0.0, min(1.0, confidence))
+
+    return PlanningContext(
+        relevant_concepts=concepts[:15],
+        prior_findings=findings[:5],
+        known_constraints=constraints[:10],
+        related_methods=methods[:10],
+        confidence=confidence,
+    )
+
+
+def format_planning_context(ctx: PlanningContext, max_tokens: int = 300) -> str:
+    """Render PlanningContext as concise bullet list; only non-empty sections; prepend confidence."""
+    parts = []
+    if ctx.confidence >= 0.7:
+        parts.append("High confidence")
+    elif ctx.confidence >= 0.3:
+        parts.append("Partial context")
+    if ctx.relevant_concepts:
+        parts.append("Concepts: " + ", ".join(ctx.relevant_concepts[:10]))
+    if ctx.prior_findings:
+        parts.append("Prior findings: " + " | ".join(s[:80] for s in ctx.prior_findings[:5]))
+    if ctx.known_constraints:
+        parts.append("Constraints: " + "; ".join(ctx.known_constraints[:5]))
+    if ctx.related_methods:
+        parts.append("Methods: " + ", ".join(ctx.related_methods[:8]))
+    text = "\n".join(parts)
+    if len(text) > max_tokens * 4:
+        text = text[: max_tokens * 4] + "..."
+    return text

devsper/memory/__init__.py

@@ -0,0 +1,35 @@
+"""
+Swarm memory: persistent store, semantic index, and router for agent recall.
+
+- memory_types: EpisodicMemory, SemanticMemory, ArtifactMemory, ResearchMemory
+- memory_store: SQLite-backed store (store, retrieve, delete, list)
+- memory_index: vector/semantic search (query_memory, top_k)
+- memory_router: select relevant memories for a task
+"""
+
+from devsper.memory.memory_types import (
+    EpisodicMemory,
+    SemanticMemory,
+    ArtifactMemory,
+    ResearchMemory,
+    MemoryRecord,
+    MemoryType,
+)
+from devsper.memory.memory_store import MemoryStore
+from devsper.memory.memory_index import MemoryIndex
+from devsper.memory.memory_router import MemoryRouter
+
+__all__ = [
+    "EpisodicMemory",
+    "SemanticMemory",
+    "ArtifactMemory",
+    "ResearchMemory",
+    "MemoryRecord",
+    "MemoryType",
+    "MemoryStore",
+    "MemoryIndex",
+    "MemoryRouter",
+]
+
+# Optional: import submodules for summarizer, namespaces, scoring
+# from devsper.memory import summarizer, namespaces, scoring

devsper/memory/consolidation.py

@@ -0,0 +1,138 @@
+"""
+v1.8: Memory consolidation — cluster similar records, summarize clusters, archive originals.
+"""
+
+from dataclasses import dataclass
+
+from devsper.memory.memory_store import MemoryStore
+from devsper.memory.memory_index import MemoryIndex
+from devsper.memory.memory_types import MemoryRecord, MemoryType
+from devsper.memory.memory_store import generate_memory_id
+from devsper.utils.models import generate
+
+
+@dataclass
+class ConsolidationReport:
+    clusters_found: int
+    clusters_consolidated: int
+    records_archived: int
+    records_created: int
+    tokens_saved_estimate: int
+
+
+def _cosine_sim(a: list[float], b: list[float]) -> float:
+    if not a or not b or len(a) != len(b):
+        return 0.0
+    dot = sum(x * y for x, y in zip(a, b))
+    na = sum(x * x for x in a) ** 0.5
+    nb = sum(x * x for x in b) ** 0.5
+    if na == 0 or nb == 0:
+        return 0.0
+    return dot / (na * nb)
+
+
+class MemoryConsolidator:
+    """
+    Clusters similar memory records, summarizes each cluster into one
+    high-quality record, archives originals. Keeps agent context tight
+    for long-running projects.
+    """
+
+    def __init__(self, min_cluster_size: int = 3):
+        self.min_cluster_size = min_cluster_size
+
+    async def _summarize_cluster(self, records: list[MemoryRecord], model: str) -> str:
+        """Synthesize N related memory records into one comprehensive record. Max 300 words."""
+        blocks = "\n\n".join((r.content or "")[:500] for r in records[:20])
+        prompt = f"""Synthesize these {len(records)} related memory records into one comprehensive, information-dense record. Preserve all unique facts. Max 300 words.
+
+Records:
+{blocks}"""
+        out = generate(model, prompt)
+        return (out or "").strip()[:2000]
+
+    async def consolidate(
+        self,
+        memory_store: MemoryStore,
+        memory_index: MemoryIndex,
+        worker_model: str,
+        dry_run: bool = False,
+    ) -> ConsolidationReport:
+        """
+        1. Load all memory records (include archived for clustering? No - only non-archived)
+        2. Cluster by embedding similarity (AgglomerativeClustering, distance_threshold=0.25)
+        3. For clusters with >= min_cluster_size records: generate summary
+        4. Store summary as new MemoryRecord (type=semantic, tagged "consolidated")
+        5. Archive originals: set archived=True
+        6. Return report
+        """
+        try:
+            from sklearn.cluster import AgglomerativeClustering
+            import numpy as np
+        except ImportError:
+            raise ImportError(
+                "Memory consolidation requires scikit-learn. Install with: pip install devsper[data]"
+            ) from None
+
+        records = memory_store.list_memory(limit=5000, include_archived=False)
+        with_emb = [r for r in records if r.embedding is not None]
+        if len(with_emb) < self.min_cluster_size:
+            return ConsolidationReport(
+                clusters_found=0,
+                clusters_consolidated=0,
+                records_archived=0,
+                records_created=0,
+                tokens_saved_estimate=0,
+            )
+
+        X = np.array(with_emb[0].embedding)
+        for r in with_emb[1:]:
+            X = np.vstack([X, r.embedding])
+        clustering = AgglomerativeClustering(
+            n_clusters=None,
+            distance_threshold=0.25,
+            metric="cosine",
+            linkage="average",
+        )
+        labels = clustering.fit_predict(X)
+        unique_labels = set(labels)
+        clusters_found = len(unique_labels)
+        clusters_consolidated = 0
+        records_archived = 0
+        records_created = 0
+        avg_tokens = 100
+
+        for lab in unique_labels:
+            indices = [i for i, l in enumerate(labels) if l == lab]
+            cluster_records = [with_emb[i] for i in indices]
+            if len(cluster_records) < self.min_cluster_size:
+                continue
+            clusters_consolidated += 1
+            if dry_run:
+                records_archived += len(cluster_records)
+                records_created += 1
+                continue
+            summary_text = await self._summarize_cluster(cluster_records, worker_model)
+            summary_record = MemoryRecord(
+                id=generate_memory_id(),
+                memory_type=MemoryType.SEMANTIC,
+                content=summary_text,
+                tags=["consolidated"],
+                run_id="",
+                archived=False,
+            )
+            summary_record = memory_index.ensure_embedding(summary_record)
+            memory_store.store(summary_record)
+            records_created += 1
+            for r in cluster_records:
+                memory_store.set_archived(r.id, True)
+                records_archived += 1
+
+        tokens_saved_estimate = records_archived * avg_tokens
+        return ConsolidationReport(
+            clusters_found=clusters_found,
+            clusters_consolidated=clusters_consolidated,
+            records_archived=records_archived,
+            records_created=records_created,
+            tokens_saved_estimate=tokens_saved_estimate,
+        )