iatoolkit 2.62.1__tar.gz → 2.64.0__tar.gz

{iatoolkit-2.62.1/src/iatoolkit.egg-info → iatoolkit-2.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.62.1
+Version: 2.64.0
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT

{iatoolkit-2.62.1 → iatoolkit-2.64.0}/pyproject.toml

@@ -160,7 +160,7 @@ exclude = ["tests*", "*/tests*"]
 version = { attr = "iatoolkit.__version__" }
 
 [tool.setuptools.package-data]
-iatoolkit = ["templates/**/*", "static/**/*", "locales/*.yaml", "config/*.yaml", "config/system_prompts/*.prompt"]
+iatoolkit = ["templates/**/*", "static/**/*", "locales/*.yaml", "config/*.yaml", "config/system_prompts/*.prompt", "config/system_agents/*.prompt"]
 
 # Declared so the suite behaves identically however it is launched. Before this,
 # the layout worked only by accident: `src/tests/__init__.py` made pytest insert

{iatoolkit-2.62.1 → iatoolkit-2.64.0}/src/iatoolkit/__init__.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-__version__ = "2.62.1"
+__version__ = "2.64.0"
 
 # Expose main classes and functions at the top level of the package
 

{iatoolkit-2.62.1 → iatoolkit-2.64.0}/src/iatoolkit/common/routes.py

@@ -52,6 +52,7 @@ def register_views(app):
     from iatoolkit.views.tool_api_view import ToolApiView
     from iatoolkit.views.api_key_api_view import ApiKeyApiView
     from iatoolkit.views.memory_api_view import MemoryApiView
+    from iatoolkit.views.wiki_page_view import WikiPageView
 
     # Dependency-free liveness endpoint for load balancer/orchestrator health
     # checks (ALB, ECS, Docker HEALTHCHECK, etc). Deliberately returns a plain
@@ -103,6 +104,14 @@ def register_views(app):
                      view_func=AccountView.as_view('account'),
                      methods=['GET', 'POST'])
 
+    # a knowledge wiki page in the browser: where the wiki tools' `url` points
+    wiki_page_view = WikiPageView.as_view('wiki_page')
+    app.add_url_rule('/<company_short_name>/wiki/<wiki_key>/',
+                     defaults={'page_path': ''},
+                     view_func=wiki_page_view)
+    app.add_url_rule('/<company_short_name>/wiki/<wiki_key>/<path:page_path>',
+                     view_func=wiki_page_view)
+
     # this endpoint is called when onboarding_shell finish the context load
     app.add_url_rule(
         '/<company_short_name>/finalize',

iatoolkit-2.64.0/src/iatoolkit/config/system_agents/memory_compiler.prompt

@@ -0,0 +1,37 @@
+You maintain the company's Memory: a wiki of how things are actually done in this company (procedures, rules, exceptions, who decides), written from what its people explained.
+
+A person just saved something new (NEW_CAPTURE). Decide what to do with it:
+
+- `update` one of the CANDIDATE_PAGES when the capture belongs to its subject.
+- `create` a new page when no candidate covers the subject. Check PAGE_INDEX first: do not create a page that duplicates an existing one.
+- `skip` when the capture has nothing durable to keep (a greeting, a test, a personal reminder, something already on the page).
+
+How to write the page:
+
+- Follow the WIKI_SCHEMA.
+- When you update, return the COMPLETE new page: keep everything already on it, word for word, including other people's attributions, headings and order. Change only what the capture changes, and put new facts in the section where they belong.
+- When the capture contradicts the page, keep both statements with their attributions and make the conflict explicit; never delete what someone else said.
+- Attribute every fact you add as ({{ author }}, {{ captured_on }}).
+- Write in the language of the page, or of the capture for a new page. Neutral tone, no personal opinions.
+- If attachments come with the capture, use what they say as part of the capture.
+
+Answer with JSON following the schema:
+
+- `action`: create, update or skip.
+- `target_page_id`: the page_id of the candidate you update; null when you create or skip.
+- `title`: the page title.
+- `summary`: one sentence saying what the page covers.
+- `markdown`: the page body without frontmatter, starting with `# Title`.
+- `change_summary`: one short sentence for the page history (when you skip, why).
+
+WIKI_SCHEMA:
+{{ wiki_schema }}
+
+PAGE_INDEX:
+{{ page_index | json }}
+
+NEW_CAPTURE (from {{ author }}, {{ captured_on }}):
+{{ capture | json }}
+
+CANDIDATE_PAGES:
+{{ candidate_pages | json }}

iatoolkit-2.64.0/src/iatoolkit/config/system_agents/memory_correction.prompt

@@ -0,0 +1,22 @@
+You maintain the company's Memory wiki. A person asked for ONE change to ONE page (REQUEST). Apply only that change.
+
+Rules:
+
+- Keep every other line of the page exactly as it is, word for word: other people's attributions, headings, order and formatting. Do not rephrase, reorganize, summarize or fix anything else.
+- On the line you change or add, replace the old attribution with ({{ author }}, {{ captured_on }}).
+- If the request does not apply to this page, or you cannot tell what to change, do not guess: return `skip`.
+
+Answer with JSON following the schema:
+
+- `action`: `update` when you applied the change, `skip` when you did not.
+- `target_page_id`: {{ page.id }}.
+- `title`: the page title (keep it unless the request asks to change it).
+- `summary`: the page summary (keep it unless the change makes it wrong).
+- `markdown`: with `update`, the COMPLETE new page body without frontmatter, starting with `# Title`; with `skip`, an empty string.
+- `change_summary`: with `update`, one sentence saying what changed, in the language of the page; with `skip`, why you did not change anything, in the language of the request.
+
+REQUEST (from {{ author }}, {{ captured_on }}):
+{{ request }}
+
+PAGE (id {{ page.id }}, title {{ page.title | json }}):
+{{ page.markdown }}

iatoolkit-2.64.0/src/iatoolkit/config/system_agents/memory_question_review.prompt

@@ -0,0 +1,23 @@
+You review conversations between people and the company's AI assistant. In each turn below the assistant searched the company's memory or documents to answer a question about the company (a turn with no answer is a search that found nothing).
+
+Your job is to find the questions about the company that went unanswered, so someone who knows can answer them.
+
+For each turn decide `answered`:
+
+- true when the answer gave a concrete answer based on the company's own information;
+- false when the assistant said it did not find it or did not know, gave only generic advice, or sent the person to ask someone else.
+
+For each turn with answered=false also return:
+
+- `question`: the question rewritten as one neutral sentence, in the language of the turn, without names of people, personal details or the conversation's wording, so anyone in the company could answer it;
+- `topic`: two or three words for its subject;
+- `same_as_question_id`: the id of the OPEN QUESTION that asks the same thing, or null;
+- `same_as_ref`: when it asks the same as an earlier unanswered turn of this batch that is not an open question yet, that turn's ref; otherwise null.
+
+Return exactly one item per turn, with its `ref`, under `items`.
+
+OPEN QUESTIONS:
+{{ open_questions | json }}
+
+TURNS:
+{{ turns | json }}

iatoolkit-2.64.0/src/iatoolkit/config/system_agents_pack.yaml

@@ -0,0 +1,102 @@
+# System agents: model calls the platform makes on its own (see
+# services/system_agent_catalog.py). The tenant may pick each one's model
+# (system_agents.<key>.model in company.yaml); the prompt, inputs and output
+# schema belong to the code that reads the answer and are not editable.
+#
+# `prompt` is a Jinja template in system_agents/, rendered with `inputs`.
+# `default_model: null` means the company's default model.
+version: 1
+
+schemas:
+  # A Memoria page created, updated or left alone.
+  memory_page:
+    type: object
+    properties:
+      action:
+        type: string
+        enum: [create, update, skip]
+      # Nullable as a type list: the structured-output validator rejects null under anyOf.
+      target_page_id:
+        type: [integer, "null"]
+      title:
+        type: string
+      summary:
+        type: string
+      markdown:
+        type: string
+      change_summary:
+        type: string
+    # Only what a page cannot do without: models often drop the optional
+    # fields, and a near miss is repaired by the compiler's normalizer.
+    required: [action, target_page_id, title, markdown]
+    additionalProperties: false
+
+agents:
+  - key: memory_compiler
+    name: Compilador de Memoria
+    name_en: Memory compiler
+    description: >-
+      (Memoria de la empresa) Integra lo que la gente guarda en Memoria en la página que corresponde,
+      o crea una nueva, atribuyendo cada dato a su autor.
+    description_en: >-
+      (Company memory) Files what people save in Memory into the right page, or creates a new
+      one, attributing every fact to its author.
+    module: memory
+    prompt: memory_compiler.prompt
+    output_schema: memory_page
+    inputs: [author, captured_on, wiki_schema, page_index, capture, candidate_pages]
+    default_model: null
+
+  - key: memory_correction
+    name: Corrector de Memoria
+    name_en: Memory corrector
+    description: >-
+      (Memoria de la empresa) Aplica a una página de Memoria el cambio que alguien pidió, sin tocar el
+      resto de la página.
+    description_en: >-
+      (Company memory) Applies to a Memory page the change someone asked for, leaving the rest
+      of the page as it is.
+    module: memory
+    prompt: memory_correction.prompt
+    output_schema: memory_page
+    inputs: [author, captured_on, request, page]
+    default_model: null
+
+  - key: memory_question_review
+    name: Revisión de preguntas sin respuesta
+    name_en: Unanswered questions review
+    description: >-
+      (Memoria de la empresa) Revisa las conversaciones que buscaron en Memoria o en los documentos y
+      detecta las preguntas que la IA no pudo responder.
+    description_en: >-
+      (Company memory) Reviews the conversations that searched Memory or the documents and finds
+      the questions the AI could not answer.
+    module: memory
+    prompt: memory_question_review.prompt
+    output_schema:
+      type: object
+      properties:
+        items:
+          type: array
+          items:
+            type: object
+            properties:
+              ref:
+                type: string
+              answered:
+                type: boolean
+              question:
+                type: string
+              topic:
+                type: string
+              # Nullable as a type list: core's validator rejects null under anyOf.
+              same_as_question_id:
+                type: [integer, "null"]
+              same_as_ref:
+                type: [string, "null"]
+            required: [ref, answered]
+            additionalProperties: false
+      required: [items]
+      additionalProperties: false
+    inputs: [open_questions, turns]
+    default_model: null

{iatoolkit-2.62.1 → iatoolkit-2.64.0}/src/iatoolkit/config/system_tools_pack.yaml

@@ -378,7 +378,7 @@ tools:
       required:
         - document_id
   - function_name: iat_wiki_search
-    description: Busca páginas publicadas dentro de las wikis de conocimiento compartidas por la empresa. Úsala como acelerador cuando necesites encontrar rápidamente una página relevante, pero no como punto de entrada por defecto. Si no conoces un `path` válido, primero llama `iat_wiki_get_page` con `path="/"` para leer el índice raíz de la wiki y seguir sus links exactos. `wiki_key` es el identificador estable de una wiki publicada, por ejemplo `sales`, `ops` o `hr`; úsalo cuando ya sepas en qué wiki buscar y omítelo cuando quieras buscar en todas las wikis publicadas disponibles en esta conexión MCP. Esta tool devuelve candidatos; luego usa `iat_wiki_get_page` para leer la página completa antes de responder.
+    description: Busca páginas publicadas dentro de las wikis de conocimiento compartidas por la empresa. Úsala como acelerador cuando necesites encontrar rápidamente una página relevante, pero no como punto de entrada por defecto. Si no conoces un `path` válido, primero llama `iat_wiki_get_page` con `path="/"` para leer el índice raíz de la wiki y seguir sus links exactos. `wiki_key` es el identificador estable de una wiki publicada, por ejemplo `sales`, `ops` o `hr`; úsalo cuando ya sepas en qué wiki buscar y omítelo cuando quieras buscar en todas las wikis publicadas disponibles en esta conexión MCP. Esta tool devuelve candidatos; luego usa `iat_wiki_get_page` para leer la página completa antes de responder. Cada candidato trae `url`, el link para abrir la página en el navegador.
     routing:
       force_include_capability: has_knowledge_wikis
     routing_profile:
@@ -427,7 +427,7 @@ tools:
     description: |-
       Wiki entrypoint: llama `iat_wiki_get_page` con `path="/"` para cargar el índice raíz de una wiki de conocimiento publicada del tenant.
       Lee **una** página de wiki y devuelve su contenido en Markdown. La wiki documenta contexto de negocio, áreas, sistemas internos, arquitectura, procesos, políticas, runbooks, onboarding, operaciones y glosarios. Es una wiki navegable por links: la página raíz `path="/"` es el punto de entrada y lista las páginas disponibles con sus paths exactos; después abre solo las páginas relevantes siguiendo esos links o los paths devueltos por iat_wiki_search (solo si esta habilitada).
-      `wiki_key` identifica la wiki publicada. Los `path` son sensibles a mayúsculas y deben coincidir EXACTAMENTE con el link o path publicado; no los inventes ni los reconstruyas de memoria. Si no conoces un path válido, vuelve a llamar con `path="/"`. Esta tool es de solo lectura y es segura de usar siempre que la documentación interna de la empresa ayude a responder. Prefiere abrir pocas páginas puntuales antes de recorrer el corpus completo. Cuando respondas usando material de la wiki, cita la página usada.
+      `wiki_key` identifica la wiki publicada. Los `path` son sensibles a mayúsculas y deben coincidir EXACTAMENTE con el link o path publicado; no los inventes ni los reconstruyas de memoria. Si no conoces un path válido, vuelve a llamar con `path="/"`. Esta tool es de solo lectura y es segura de usar siempre que la documentación interna de la empresa ayude a responder. Prefiere abrir pocas páginas puntuales antes de recorrer el corpus completo. Cuando respondas usando material de la wiki, cita la página usada; si trae `url`, cítala como link con esa URL exacta.
     routing:
       force_include_capability: has_knowledge_wikis
     routing_profile:

{iatoolkit-2.62.1 → iatoolkit-2.64.0}/src/iatoolkit/core.py

@@ -439,6 +439,7 @@ class IAToolkit:
         from iatoolkit.services.mail_service import MailService
         from iatoolkit.services.memory_compiler_service import MemoryCompilerService
         from iatoolkit.services.memory_question_service import MemoryQuestionService
+        from iatoolkit.services.system_agent_runner import SystemAgentRunner
         from iatoolkit.services.memory_service import MemoryService
         from iatoolkit.services.mcp_token_service import McpTokenService
         from iatoolkit.services.memory_wiki_service import MemoryWikiService
@@ -483,6 +484,7 @@ class IAToolkit:
         binder.bind(PdfService, to=PdfService)
         binder.bind(MailService, to=MailService)
         binder.bind(MemoryWikiService, to=MemoryWikiService)
+        binder.bind(SystemAgentRunner, to=SystemAgentRunner)
         binder.bind(MemoryCompilerService, to=MemoryCompilerService)
         binder.bind(MemoryQuestionService, to=MemoryQuestionService)
         binder.bind(MemoryService, to=MemoryService)

{iatoolkit-2.62.1 → iatoolkit-2.64.0}/src/iatoolkit/locales/en.yaml

@@ -377,6 +377,14 @@ ui:
     last_used: "Last used"
     never_used: "No recorded use"
 
+  wiki_page:
+    back_to_chat: "Back to chat"
+    trail_label: "Location in the wiki"
+    empty: "This page has no content."
+    not_found: "This page does not exist in the wiki or is no longer published."
+    forbidden: "You do not have access to this page."
+    forbidden_labels: "You do not have access to this page. You need one of these labels: {labels}."
+    unavailable: "We could not verify your access right now. Try again in a few minutes."
   memory:
     title: "Company memory"
     capture_title: "Teach the company something"

{iatoolkit-2.62.1 → iatoolkit-2.64.0}/src/iatoolkit/locales/es.yaml

@@ -391,6 +391,14 @@ ui:
     last_used: "Último uso"
     never_used: "Sin uso registrado"
 
+  wiki_page:
+    back_to_chat: "Volver al chat"
+    trail_label: "Ubicación en la wiki"
+    empty: "Esta página no tiene contenido."
+    not_found: "Esta página no existe en la wiki o ya no está publicada."
+    forbidden: "No tienes acceso a esta página."
+    forbidden_labels: "No tienes acceso a esta página. Necesitas alguna de estas etiquetas: {labels}."
+    unavailable: "No pudimos verificar tu acceso en este momento. Intenta de nuevo en unos minutos."
   memory:
     title: "Memoria de la empresa"
     capture_title: "Enseñar algo a la empresa"

{iatoolkit-2.62.1 → iatoolkit-2.64.0}/src/iatoolkit/services/configuration_service.py

@@ -313,6 +313,37 @@ class ConfigurationService:
 
         return config, []
 
+    def remove_configuration_key(self, company_short_name: str, key: str) -> tuple[dict, list[str]]:
+        """
+        Removes a key (dot notation) from company.yaml, so a setting that went back
+        to its default leaves no empty section behind. A missing key is not an error.
+        """
+        main_config_filename = "company.yaml"
+        if not self.asset_repo.exists(company_short_name, AssetType.CONFIG, main_config_filename):
+            raise FileNotFoundError(f"Configuration file not found for {company_short_name}")
+
+        yaml_content = self.asset_repo.read_text(company_short_name, AssetType.CONFIG, main_config_filename)
+        config = self.utility.load_yaml_from_string(yaml_content) or {}
+
+        *parents, last = key.split('.')
+        current = config
+        for part in parents:
+            current = current.get(part) if isinstance(current, dict) else None
+        if not isinstance(current, dict) or last not in current:
+            return config, []
+        current.pop(last)
+
+        errors = self._validate_configuration(company_short_name, config)
+        if errors:
+            logging.warning(f"Configuration update failed validation: {errors}")
+            return config, errors
+
+        self.asset_repo.write_text(company_short_name, AssetType.CONFIG, main_config_filename,
+                                   self.utility.dump_yaml_to_string(config))
+        if company_short_name in self._loaded_configs:
+            del self._loaded_configs[company_short_name]
+        return config, []
+
     def add_configuration_key(self, company_short_name: str, parent_key: str, key: str, value) -> tuple[dict, list[str]]:
         """
         Adds a new key-value pair under a specific parent key in the configuration.
@@ -500,6 +531,18 @@ class ConfigurationService:
             else:
                 self._validate_mcp_url_config(mcp_config, add_error)
 
+        # The model the tenant picked for each system agent (see SystemAgentRunner).
+        system_agents = config.get("system_agents")
+        if system_agents is not None:
+            if not isinstance(system_agents, dict):
+                add_error("system_agents", "Must be a dictionary of agent keys.")
+            else:
+                for agent_key, agent_config in system_agents.items():
+                    if not isinstance(agent_config, dict):
+                        add_error(f"system_agents.{agent_key}", "Must be a dictionary.")
+                    elif agent_config.get("model") is not None and not isinstance(agent_config.get("model"), str):
+                        add_error(f"system_agents.{agent_key}.model", "Must be a single model name.")
+
         # 2. LLM section
         if not isinstance(config.get("llm"), dict):
             add_error("llm", "Missing or invalid 'llm' section.")

{iatoolkit-2.62.1 → iatoolkit-2.64.0}/src/iatoolkit/services/memory_compiler_service.py

@@ -6,7 +6,6 @@
 from __future__ import annotations
 
 import base64
-import json
 import logging
 import mimetypes
 import re
@@ -22,10 +21,9 @@ from iatoolkit.repositories.database_manager import DatabaseManager
 from iatoolkit.repositories.memory_repo import MemoryRepo
 from iatoolkit.repositories.models import Company, MemoryCapture, MemoryCaptureStatus, MemoryItem, MemoryItemStatus, MemoryItemType
 from iatoolkit.repositories.profile_repo import ProfileRepo
-from iatoolkit.services.configuration_service import ConfigurationService
-from iatoolkit.services.llm_client_service import llmClient
 from iatoolkit.services.memory_wiki_service import MemoryWikiService
 from iatoolkit.services.storage_service import StorageService
+from iatoolkit.services.system_agent_runner import SystemAgentRunner
 from iatoolkit.services.tenant_wiki_service import TenantWikiService
 
 
@@ -58,42 +56,22 @@ class MemoryCompilerService:
     # First key of the two-key Postgres advisory lock; the second is the company id.
     ADVISORY_LOCK_NAMESPACE = 734001
 
-    PAGE_SCHEMA = {
-        "type": "object",
-        "properties": {
-            "action": {"type": "string", "enum": ["create", "update", "skip"]},
-            # Nullable as a type list: the structured-output validator rejects null under anyOf.
-            "target_page_id": {"type": ["integer", "null"]},
-            "title": {"type": "string"},
-            "summary": {"type": "string"},
-            "markdown": {"type": "string"},
-            "change_summary": {"type": "string"},
-        },
-        # Only what a page cannot do without: models often drop the optional
-        # fields, and a near miss is repaired by _normalize_compiled_output.
-        "required": [
-            "action",
-            "target_page_id",
-            "title",
-            "markdown",
-        ],
-        "additionalProperties": False,
-    }
+    # System agents (config/system_agents_pack.yaml) that write the pages.
+    COMPILER_AGENT = "memory_compiler"
+    CORRECTION_AGENT = "memory_correction"
 
     @inject
     def __init__(self,
                  profile_repo: ProfileRepo,
                  memory_repo: MemoryRepo,
                  memory_wiki_service: MemoryWikiService,
-                 llm_client: llmClient,
-                 configuration_service: ConfigurationService,
+                 system_agent_runner: SystemAgentRunner,
                  storage_service: StorageService,
                  db_manager: DatabaseManager):
         self.profile_repo = profile_repo
         self.memory_repo = memory_repo
         self.memory_wiki_service = memory_wiki_service
-        self.llm_client = llm_client
-        self.configuration_service = configuration_service
+        self.system_agent_runner = system_agent_runner
         self.storage_service = storage_service
         self.db_manager = db_manager
 
@@ -320,41 +298,23 @@ class MemoryCompilerService:
                                      page: dict,
                                      author: str,
                                      captured_on: str) -> dict | None:
-        model, _ = self.configuration_service.get_llm_configuration(company.short_name)
-        if not model:
-            return None
         request = "\n".join(str(item.content_text or "").strip() for item in items if str(item.content_text or "").strip())
-        prompt = (
-            "You maintain the company's memory wiki. A person asked for ONE change to one page.\n"
-            "Apply only that change. Keep every other line of the page exactly as it is, word for word, "
-            "including other people's attributions, headings and order. Do not rephrase, reorganize or summarize.\n"
-            f"Attribute the line you change or add as ({author}, {captured_on}), replacing the attribution "
-            "the old statement had on that line.\n"
-            "If the request does not apply to this page or you cannot tell what to change, return action "
-            "\"skip\" and explain why in change_summary, in the language of the request.\n"
-            "Otherwise return action \"update\" with the COMPLETE new page body in `markdown` (without "
-            "frontmatter, starting with `# Title`) and a one-sentence `change_summary` in the language of the page.\n\n"
-            f"REQUEST (from {author}, {captured_on}):\n{request}\n\n"
-            f"PAGE (id {page.get('id')}, title {json.dumps(page.get('title') or '', ensure_ascii=False)}):\n"
-            f"{self.memory_wiki_service.page_body(page)}"
-        )
         try:
-            response = self.llm_client.invoke(
-                company=company,
+            response = self.system_agent_runner.run(
+                company,
+                self.CORRECTION_AGENT,
+                {
+                    "author": author,
+                    "captured_on": captured_on,
+                    "request": request,
+                    "page": {
+                        "id": page.get("id"),
+                        "title": page.get("title") or "",
+                        "markdown": self.memory_wiki_service.page_body(page),
+                    },
+                },
                 user_identifier=capture.user_identifier,
-                previous_response_id=None,
                 question=f"Apply memory correction {capture.id}",
-                context=prompt,
-                tools=[],
-                text={},
-                model=model,
-                images=[],
-                attachments=[],
-                response_contract={
-                    "schema": self.PAGE_SCHEMA,
-                    "schema_mode": "best_effort",
-                    "response_mode": "structured_only",
-                },
             )
         except Exception as exc:
             logging.warning("Memory correction %s could not reach the model: %s", capture.id, exc)
@@ -427,11 +387,7 @@ class MemoryCompilerService:
                           candidates: list[dict],
                           author: str,
                           captured_on: str) -> dict | None:
-        model, _ = self.configuration_service.get_llm_configuration(company.short_name)
-        if not model:
-            return None
-
-        prompt = self._build_compiler_prompt(
+        inputs = self._compiler_inputs(
             capture,
             items,
             candidates,
@@ -442,22 +398,13 @@ class MemoryCompilerService:
         )
         native_pdf_attachments = self._build_capture_native_pdf_attachments(company.short_name, items)
         try:
-            response = self.llm_client.invoke(
-                company=company,
+            response = self.system_agent_runner.run(
+                company,
+                self.COMPILER_AGENT,
+                inputs,
                 user_identifier=capture.user_identifier,
-                previous_response_id=None,
                 question=f"Compile memory capture {capture.id}",
-                context=prompt,
-                tools=[],
-                text={},
-                model=model,
-                images=[],
                 attachments=native_pdf_attachments,
-                response_contract={
-                    "schema": self.PAGE_SCHEMA,
-                    "schema_mode": "best_effort",
-                    "response_mode": "structured_only",
-                },
             )
         except Exception as exc:
             logging.warning("Memory compiler LLM fallback activated for capture %s: %s", capture.id, exc)
@@ -525,61 +472,51 @@ class MemoryCompilerService:
             "change_summary": "Creada sin modelo de lenguaje.",
         }
 
-    def _build_compiler_prompt(self,
-                               capture: MemoryCapture,
-                               items: list[MemoryItem],
-                               candidates: list[dict],
-                               *,
-                               author: str,
-                               captured_on: str,
-                               wiki_schema: str = "",
-                               index_entries: list[dict] | None = None) -> str:
-        capture_payload = {
-            "capture_id": capture.id,
+    def _compiler_inputs(self,
+                         capture: MemoryCapture,
+                         items: list[MemoryItem],
+                         candidates: list[dict],
+                         *,
+                         author: str,
+                         captured_on: str,
+                         wiki_schema: str = "",
+                         index_entries: list[dict] | None = None) -> dict:
+        """What the memory_compiler agent receives (see its prompt)."""
+        return {
             "author": author,
-            "date": captured_on,
-            "title": capture.title,
-            "items": [
+            "captured_on": captured_on,
+            "wiki_schema": str(wiki_schema or "")[:7000],
+            "page_index": [
+                {"page_id": entry.get("id"), "title": entry.get("title"), "summary": entry.get("summary")}
+                for entry in (index_entries or [])[:self.MAX_INDEX_ENTRIES_IN_PROMPT]
+            ],
+            "capture": {
+                "capture_id": capture.id,
+                "author": author,
+                "date": captured_on,
+                "title": capture.title,
+                "items": [
+                    {
+                        "id": item.id,
+                        "item_type": item.item_type.value if hasattr(item.item_type, "value") else str(item.item_type),
+                        "title": item.title,
+                        "content_text": item.content_text,
+                        "source_url": item.source_url,
+                        "filename": item.filename,
+                        "mime_type": item.mime_type,
+                    }
+                    for item in items
+                ],
+            },
+            "candidate_pages": [
                 {
-                    "id": item.id,
-                    "item_type": item.item_type.value if hasattr(item.item_type, "value") else str(item.item_type),
-                    "title": item.title,
-                    "content_text": item.content_text,
-                    "source_url": item.source_url,
-                    "filename": item.filename,
-                    "mime_type": item.mime_type,
+                    "page_id": page.get("id"),
+                    "title": page.get("title"),
+                    "markdown": self.memory_wiki_service.page_body(page),
                 }
-                for item in items
+                for page in candidates or []
             ],
         }
-        index_payload = [
-            {"page_id": entry.get("id"), "title": entry.get("title"), "summary": entry.get("summary")}
-            for entry in (index_entries or [])[:self.MAX_INDEX_ENTRIES_IN_PROMPT]
-        ]
-        candidate_payload = [
-            {
-                "page_id": page.get("id"),
-                "title": page.get("title"),
-                "markdown": self.memory_wiki_service.page_body(page),
-            }
-            for page in candidates or []
-        ]
-        return (
-            "You maintain the company's memory wiki: how things are actually done in this company.\n"
-            "Follow the wiki schema. Decide whether the new capture updates one candidate page, "
-            "creates a new page, or should be skipped (nothing durable to keep).\n"
-            "When you update a page, return its COMPLETE new markdown: keep everything already on it, "
-            "including other people's attributions, and change only what the capture changes.\n"
-            f"Attribute every fact you add as ({author}, {captured_on}).\n"
-            "Return JSON only, following the provided schema. `markdown` is the page body without "
-            "frontmatter, starting with `# Title`. `change_summary` is one short sentence for the page history.\n\n"
-            f"WIKI_SCHEMA:\n{wiki_schema[:7000]}\n\n"
-            f"PAGE_INDEX:\n{json.dumps(index_payload, ensure_ascii=False)}\n\n"
-            f"NEW_CAPTURE:\n{json.dumps(capture_payload, ensure_ascii=False)}\n\n"
-            f"CANDIDATE_PAGES:\n{json.dumps(candidate_payload, ensure_ascii=False)}\n\n"
-            "If you update a page, set target_page_id to its page_id. "
-            "If you create a page, set target_page_id to null."
-        )
 
     def _author_label(self, user_identifier: str | None) -> str:
         identifier = str(user_identifier or "").strip()