iatoolkit 2.63.0__tar.gz → 2.64.0__tar.gz

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

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

{iatoolkit-2.63.0 → 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.63.0 → iatoolkit-2.64.0}/src/iatoolkit/__init__.py

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

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.63.0 → 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.63.0 → 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.63.0 → 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()