iatoolkit 2.70.0__tar.gz → 2.71.1__tar.gz

{iatoolkit-2.70.0/src/iatoolkit.egg-info → iatoolkit-2.71.1}/PKG-INFO

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

{iatoolkit-2.70.0 → iatoolkit-2.71.1}/src/iatoolkit/__init__.py

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

iatoolkit-2.71.1/src/iatoolkit/common/access.py

@@ -0,0 +1,206 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+"""Who may do what: the one question every check asks (BL-010, Fase 1).
+
+Code never names a role. It asks whether a principal (a person's email, or a
+service account `service:<key>`) has a level over a resource:
+
+    access.can(company, user_identifier, EDIT, "company")
+    access.can(company, user_identifier, USE, "agent", "cobranza")
+
+Three levels, each including the one below:
+    1 USE    use an agent, tool, model, SQL source / see content
+    2 EDIT   change the resource (an agent's prompt, a folder's documents)
+    3 ADMIN  decide on it: who has access, delete it, its settings
+
+Over the resource type "company", EDIT is entering the admin console and
+editing every resource, and ADMIN is administering the company (its team,
+settings). Billing and deleting the tenant are for its owners only (`is_owner`).
+
+Enterprise registers the decider backed by groups and grants. Without it,
+the decision falls back to the person's role in the company, as before.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Callable, Protocol
+
+USE = 1
+EDIT = 2
+ADMIN = 3
+
+LEVEL_NAMES = {USE: "use", EDIT: "edit", ADMIN: "admin"}
+
+# The level each legacy role holds over everything (core without enterprise).
+ROLE_LEVELS = {"user": USE, "editor": EDIT, "admin": ADMIN, "owner": ADMIN}
+
+
+class AccessDecider(Protocol):
+    def can(self, company_short_name: str, user_identifier: str | None, level: int,
+            resource_type: str, resource_key: str | None = None,
+            resource_path: str | None = None) -> bool: ...
+
+    def is_owner(self, company_short_name: str, user_identifier: str | None) -> bool: ...
+
+    def effective_role(self, company_short_name: str, user_identifier: str | None) -> str | None: ...
+
+
+class RoleAccessDecider:
+    """Core's fallback: the role of iat_user_company grants its level over everything."""
+
+    def __init__(self, role_reader: Callable[[str, str], str | None]):
+        self.role_reader = role_reader
+
+    def _role(self, company_short_name, user_identifier) -> str | None:
+        if not user_identifier:
+            return None
+        return self.role_reader(company_short_name, user_identifier)
+
+    def can(self, company_short_name, user_identifier, level, resource_type, resource_key=None,
+            resource_path=None) -> bool:
+        if level <= USE and resource_type != "company":
+            # Without groups nothing is restricted: whoever enters the company uses
+            # what it offers (members, and the end users a key acts for).
+            return True
+        role = self._role(company_short_name, user_identifier)
+        if role is None:
+            return False
+        return ROLE_LEVELS.get(role, USE) >= level
+
+    def is_owner(self, company_short_name, user_identifier) -> bool:
+        return self._role(company_short_name, user_identifier) == "owner"
+
+    def effective_role(self, company_short_name, user_identifier) -> str | None:
+        return self._role(company_short_name, user_identifier)
+
+
+class Access:
+    """The registered decider; enterprise replaces core's fallback at boot."""
+
+    _decider: AccessDecider | None = None
+
+    @classmethod
+    def register(cls, decider: AccessDecider) -> None:
+        cls._decider = decider
+
+    @classmethod
+    def clear(cls) -> None:
+        cls._decider = None
+
+    @classmethod
+    def registered(cls) -> bool:
+        """Whether a decider other than core's role fallback is in place (enterprise)."""
+        return cls._decider is not None and not isinstance(cls._decider, RoleAccessDecider)
+
+    @classmethod
+    def decider(cls) -> AccessDecider:
+        if cls._decider is None:
+            cls._decider = RoleAccessDecider(_role_from_profile_service)
+        return cls._decider
+
+
+def decider_for(role_reader: Callable[[str, str], str | None]) -> AccessDecider:
+    """The registered decider, or the role fallback reading roles with `role_reader`
+    (views that already hold a ProfileRepo)."""
+    return Access.decider() if Access.registered() else RoleAccessDecider(role_reader)
+
+
+def _role_from_profile_service(company_short_name: str, user_identifier: str) -> str | None:
+    from iatoolkit import current_iatoolkit
+    from iatoolkit.services.profile_service import ProfileService
+
+    return current_iatoolkit().get_injector().get(ProfileService).get_role_in_company(
+        company_short_name, user_identifier)
+
+
+def can(company_short_name: str, user_identifier: str | None, level: int, resource_type: str,
+        resource_key: str | None = None, resource_path: str | None = None) -> bool:
+    try:
+        return bool(Access.decider().can(company_short_name, user_identifier, level, resource_type,
+                                         resource_key, resource_path))
+    except Exception as exc:
+        # Deciding failed: deny, never fall open.
+        logging.warning("Access check failed (%s, %s, %s %s): %s", company_short_name, user_identifier,
+                        level, resource_type, exc)
+        return False
+
+
+def is_owner(company_short_name: str, user_identifier: str | None) -> bool:
+    try:
+        return bool(Access.decider().is_owner(company_short_name, user_identifier))
+    except Exception as exc:
+        logging.warning("Owner check failed (%s, %s): %s", company_short_name, user_identifier, exc)
+        return False
+
+
+def effective_roles(company_short_name: str, user_identifiers: list[str]) -> dict[str, str | None]:
+    """`effective_role` for many people at once (the Users screen)."""
+    decider = Access.decider()
+    try:
+        bulk = getattr(decider, "effective_roles", None)
+        if callable(bulk):
+            return bulk(company_short_name, user_identifiers)
+        return {u: decider.effective_role(company_short_name, u) for u in user_identifiers}
+    except Exception as exc:
+        logging.warning("Effective roles failed (%s): %s", company_short_name, exc)
+        return {}
+
+
+def effective_role(company_short_name: str, user_identifier: str | None) -> str | None:
+    """What the person can do over the company, as the console's old role names.
+
+    Only for screens that still show or branch on a role name (labels, menus);
+    access is always decided with `can`.
+    """
+    try:
+        return Access.decider().effective_role(company_short_name, user_identifier)
+    except Exception as exc:
+        logging.warning("Effective role failed (%s, %s): %s", company_short_name, user_identifier, exc)
+        return None
+
+
+def role_assigned(company_short_name: str, user_identifier: str, role: str) -> None:
+    """Somebody was given a legacy role (signup's bootstrap admin, company activation,
+    `init-install --owner`): the registered decider puts them in the matching group."""
+    decider = Access._decider
+    hook = getattr(decider, "role_assigned", None) if decider is not None else None
+    if callable(hook):
+        try:
+            hook(company_short_name, user_identifier, role)
+        except Exception as exc:
+            logging.warning("Role %s of %s in %s not moved to its group: %s", role, user_identifier,
+                            company_short_name, exc)
+
+
+def person_can(company_short_name: str, auth_result: dict | None, level: int, resource_type: str = "company",
+               resource_key: str | None = None) -> bool:
+    """A signed-in person's access, from an AuthService result.
+
+    Only sessions carry `user_role`; an API key is not a person and gets False
+    (each view decides on its own whether a key may pass).
+    """
+    if not isinstance(auth_result, dict) or "user_role" not in auth_result:
+        return False
+    if not Access.registered():
+        # Core alone: the session's role was just read from iat_user_company.
+        return _session_role_decider(auth_result).can(company_short_name, auth_result.get("user_identifier") or "session",
+                                                       level, resource_type, resource_key)
+    return can(company_short_name, auth_result.get("user_identifier"), level, resource_type, resource_key)
+
+
+def person_is_owner(company_short_name: str, auth_result: dict | None) -> bool:
+    if not isinstance(auth_result, dict) or "user_role" not in auth_result:
+        return False
+    if not Access.registered():
+        return _session_role_decider(auth_result).is_owner(company_short_name,
+                                                            auth_result.get("user_identifier") or "session")
+    return is_owner(company_short_name, auth_result.get("user_identifier"))
+
+
+def _session_role_decider(auth_result: dict) -> RoleAccessDecider:
+    role = str(auth_result.get("user_role") or "").strip().lower() or None
+    return RoleAccessDecider(lambda company_short_name, user_identifier: role)

{iatoolkit-2.70.0 → iatoolkit-2.71.1}/src/iatoolkit/core.py

@@ -195,6 +195,13 @@ class IAToolkit:
         thread.start()
         return thread
 
+    @staticmethod
+    def _effective_role(company_short_name: str | None, user_identifier: str | None) -> str | None:
+        if not company_short_name or not user_identifier:
+            return None
+        from iatoolkit.common import access
+        return access.effective_role(company_short_name, user_identifier)
+
     def _get_config_value(self, key: str, default=None):
         # get a value from the config dict or the environment variable
         return self.config.get(key, os.getenv(key, default))
@@ -653,7 +660,10 @@ class IAToolkit:
                 'app_name': 'IAToolkit',
                 'user_identifier': session_info.get('user_identifier'),
                 'company_short_name': route_company_short_name or session_info.get('company_short_name'),
-                'user_role': user_profile.get('user_role'),
+                # What the person can do over the company (BL-010, Fase 1), never the
+                # role an SSO hook may have written into the session profile.
+                'user_role': self._effective_role(route_company_short_name or session_info.get('company_short_name'),
+                                                  session_info.get('user_identifier')),
                 'user_is_local': user_profile.get('user_is_local'),
                 'user_email': user_profile.get('user_email'),
                 'iatoolkit_base_url': request.url_root,

{iatoolkit-2.70.0 → iatoolkit-2.71.1}/src/iatoolkit/locales/en.yaml

@@ -645,6 +645,95 @@ ui:
   admin:
     workspace: "Workspace"
     team_invitations: "Invitations"
+    team_groups: "Groups"
+    team_groups_edit: "Groups"
+    team_groups_modal_title: "Person's groups"
+    team_groups_save: "Save"
+    team_groups_close: "Close"
+    team_groups_saved: "Groups updated."
+    team_groups_everyone_hint: "Every member is in Everyone: no need to tick it."
+    team_group_new: "New group"
+    team_group_name: "Name"
+    team_group_description: "Description"
+    team_group_members: "Members"
+    team_group_add_member: "Add"
+    team_group_remove: "Remove"
+    team_group_delete: "Delete group"
+    team_group_builtin: "Built-in"
+    team_group_save: "Save"
+    team_group_no_grants_short: "Only what resources give it"
+    team_group_resources: "resources with their own access"
+    team_group_resource: "resource with its own access"
+    team_groups_empty_hint: "Create one to restrict an agent to certain people."
+    team_groups_empty_title: "No groups of your own yet"
+    team_groups_builtin: "Built-in groups"
+    team_groups_company: "Company groups"
+    team_groups_intro: "Group people to give them access to agents and other resources."
+    team_group_no_match: "Nobody in the company matches."
+    team_group_create: "Create group"
+    team_group_add_member_label: "Add a person"
+    team_group_description_placeholder: "What this group is for (optional)"
+    team_group_name_placeholder: "E.g. Risk"
+    team_group_details: "Group details"
+    team_group_edit_hint: "People in this group."
+    team_group_new_hint: "A group brings people together to give them access to agents and other resources."
+    team_group_edit: "Edit"
+    team_group_everyone_note: "Includes everyone in the company."
+    team_group_owners_note: "Only an owner can change the owners. Owners is never empty."
+    team_group_grants: "Can"
+    team_group_no_grants: "No permissions over the company."
+    team_group_owners_all: "everything, billing included"
+    team_group_delete_confirm: "Delete this group? Its permissions are lost."
+    team_group_none_members: "No members."
+    team_group_member_placeholder: "Search by name or email"
+    team_group_created: "Group created."
+    team_group_deleted: "Group deleted."
+    team_group_updated: "Group updated."
+    access_level_1: "use / see"
+    access_level_2: "edit"
+    access_level_3: "administer"
+    access_all_resources: "every resource"
+    access_company: "the company"
+    access_title: "Access"
+    access_group_owners: "Owners"
+    access_group_admins: "Administrators"
+    access_group_editors: "Editors"
+    access_group_everyone: "Everyone"
+    access_group_owners_desc: "Can do everything, including billing and deleting the company."
+    access_group_admins_desc: "Administer the company: team, agents, knowledge and settings."
+    access_group_editors_desc: "Edit every resource from the console."
+    access_group_everyone_desc: "Everyone in the company."
+    access_readonly: "Only those who administer the company can change access."
+    access_level_help_3: "Also decide who has access."
+    access_level_help_2: "Also change its configuration or content."
+    access_level_help_1_see: "Read its content, also through the AI."
+    access_level_help_1_use: "Run it in the chat, the API and MCP."
+    access_level_1_see: "see"
+    access_level_1_use: "use"
+    access_nobody: "No groups."
+    access_members: "members"
+    access_member: "member"
+    access_everyone_members: "Whole company"
+    access_remove: "Remove access"
+    access_add: "Add"
+    access_add_title_own: "Give access to another group"
+    access_add_title_default: "Restrict to a group"
+    access_always_hint: "Always have access; no need to add them."
+    access_always: "Owners and administrators"
+    access_levels: "Levels"
+    access_who: "Who has access"
+    access_mode_own: "Restricted"
+    access_mode_default: "Whole company"
+    access_heading_agent: "Who can use this agent?"
+    access_heading: "Who has access?"
+    access_default: "Company access (default)"
+    access_default_hint: "Everyone uses it under the company's general permissions. Add a group to restrict it."
+    access_own_hint: "Only the listed groups have access. Removing the last group returns it to the whole company."
+    access_add_group: "Add group"
+    access_reset: "Back to company access"
+    access_saved: "Access updated."
+    access_group: "Group"
+    access_level: "Level"
     team_invite_user: "Invite user"
     team_invite_none: "No invitations yet."
     team_invite_loading: "Loading invitations..."
@@ -2602,6 +2691,8 @@ ui:
 
 errors:
   company_not_found: "The company {company_short_name} does not exist."
+  access:
+    agent_denied: "You do not have access to the agent {prompt_name}."
   timeout: "timeout expired."
   auth:
     invalid_password: "The provided password is incorrect."

{iatoolkit-2.70.0 → iatoolkit-2.71.1}/src/iatoolkit/locales/es.yaml

@@ -659,6 +659,95 @@ ui:
   admin:
     workspace: "Recursos"
     team_invitations: "Invitaciones"
+    team_groups: "Grupos"
+    team_groups_edit: "Grupos"
+    team_groups_modal_title: "Grupos de la persona"
+    team_groups_save: "Guardar"
+    team_groups_close: "Cerrar"
+    team_groups_saved: "Grupos actualizados."
+    team_groups_everyone_hint: "Todos los miembros están en Todos: no hace falta marcarlo."
+    team_group_new: "Nuevo grupo"
+    team_group_name: "Nombre"
+    team_group_description: "Descripción"
+    team_group_members: "Miembros"
+    team_group_add_member: "Agregar"
+    team_group_remove: "Quitar"
+    team_group_delete: "Eliminar grupo"
+    team_group_builtin: "De fábrica"
+    team_group_save: "Guardar"
+    team_group_no_grants_short: "Solo lo que le den los recursos"
+    team_group_resources: "recursos con acceso propio"
+    team_group_resource: "recurso con acceso propio"
+    team_groups_empty_hint: "Crea uno para restringir un agente a ciertas personas."
+    team_groups_empty_title: "Todavía no hay grupos propios"
+    team_groups_builtin: "Grupos de fábrica"
+    team_groups_company: "Grupos de la empresa"
+    team_groups_intro: "Agrupa personas para darles acceso a agentes y otros recursos."
+    team_group_no_match: "Nadie de la empresa coincide."
+    team_group_create: "Crear grupo"
+    team_group_add_member_label: "Agregar persona"
+    team_group_description_placeholder: "Para qué es este grupo (opcional)"
+    team_group_name_placeholder: "Ej.: Riesgo"
+    team_group_details: "Datos del grupo"
+    team_group_edit_hint: "Personas de este grupo."
+    team_group_new_hint: "Un grupo reúne personas para darles acceso a agentes y otros recursos."
+    team_group_edit: "Editar"
+    team_group_everyone_note: "Incluye a todas las personas de la empresa."
+    team_group_owners_note: "Solo un dueño puede cambiar los dueños. Dueños nunca queda vacío."
+    team_group_grants: "Puede"
+    team_group_no_grants: "Sin permisos sobre la empresa."
+    team_group_owners_all: "todo, incluida la facturación"
+    team_group_delete_confirm: "¿Eliminar este grupo? Sus permisos se pierden."
+    team_group_none_members: "Sin miembros."
+    team_group_member_placeholder: "Busca por nombre o email"
+    team_group_created: "Grupo creado."
+    team_group_deleted: "Grupo eliminado."
+    team_group_updated: "Grupo actualizado."
+    access_level_1: "usar / ver"
+    access_level_2: "editar"
+    access_level_3: "administrar"
+    access_all_resources: "todos los recursos"
+    access_company: "la empresa"
+    access_title: "Acceso"
+    access_group_owners: "Dueños"
+    access_group_admins: "Administradores"
+    access_group_editors: "Editores"
+    access_group_everyone: "Todos"
+    access_group_owners_desc: "Pueden todo, incluida la facturación y eliminar la empresa."
+    access_group_admins_desc: "Administran la empresa: equipo, agentes, conocimiento y ajustes."
+    access_group_editors_desc: "Editan todos los recursos desde la consola."
+    access_group_everyone_desc: "Todas las personas de la empresa."
+    access_readonly: "Solo quienes administran la empresa pueden cambiar el acceso."
+    access_level_help_3: "Además, decidir quién tiene acceso."
+    access_level_help_2: "Además, cambiar su configuración o contenido."
+    access_level_help_1_see: "Leer su contenido, también a través de la IA."
+    access_level_help_1_use: "Ejecutarlo en el chat, la API y MCP."
+    access_level_1_see: "ver"
+    access_level_1_use: "usar"
+    access_nobody: "Ningún grupo."
+    access_members: "miembros"
+    access_member: "miembro"
+    access_everyone_members: "Toda la empresa"
+    access_remove: "Quitar acceso"
+    access_add: "Agregar"
+    access_add_title_own: "Dar acceso a otro grupo"
+    access_add_title_default: "Restringir a un grupo"
+    access_always_hint: "Siempre tienen acceso, no hace falta agregarlos."
+    access_always: "Dueños y administradores"
+    access_levels: "Niveles"
+    access_who: "Quién tiene acceso"
+    access_mode_own: "Restringido"
+    access_mode_default: "Toda la empresa"
+    access_heading_agent: "¿Quién puede usar este agente?"
+    access_heading: "¿Quién tiene acceso?"
+    access_default: "Acceso de la empresa (por defecto)"
+    access_default_hint: "Lo usan todos según los permisos generales de la empresa. Agrega un grupo para restringirlo."
+    access_own_hint: "Solo los grupos de la lista tienen acceso. Quitar el último grupo lo devuelve a toda la empresa."
+    access_add_group: "Agregar grupo"
+    access_reset: "Volver al acceso de la empresa"
+    access_saved: "Acceso actualizado."
+    access_group: "Grupo"
+    access_level: "Nivel"
     team_invite_user: "Invitar usuario"
     team_invite_none: "Todavía no hay invitaciones."
     team_invite_loading: "Cargando invitaciones..."
@@ -2617,6 +2706,8 @@ ui:
 
 errors:
   company_not_found: "La empresa {company_short_name} no existe."
+  access:
+    agent_denied: "No tienes acceso al agente {prompt_name}."
   timeout: "El tiempo de espera ha expirado."
 
 

{iatoolkit-2.70.0 → iatoolkit-2.71.1}/src/iatoolkit/services/auth_service.py

@@ -17,6 +17,7 @@ import logging
 import re
 import unicodedata
 import hashlib
+from iatoolkit.common import access
 
 
 class AuthService:
@@ -354,6 +355,13 @@ class AuthService:
         return f"{cls.SERVICE_PREFIX}{name.strip('-') or getattr(api_key_entry, 'id', 'key')}"
 
     def _role_in_company(self, company_short_name: str, user_identifier: str) -> str | None:
+        """What the person can do over the company, by its old role name (BL-010, Fase 1).
+
+        Views decide with `iatoolkit.common.access`; this name stays in the result to
+        tell a session from an API key and for screens that show it.
+        """
+        if access.Access.registered():
+            return access.effective_role(company_short_name, user_identifier)
         return self.profile_service.get_role_in_company(company_short_name, user_identifier)
 
     def verify_for_company(self, company_short_name: str, anonymous: bool = False) -> dict:

{iatoolkit-2.70.0 → iatoolkit-2.71.1}/src/iatoolkit/services/memory_wiki_service.py

@@ -12,6 +12,7 @@ from injector import inject
 
 from iatoolkit.services.markdown_wiki_service import MarkdownWikiService
 from iatoolkit.services.tenant_wiki_service import TenantWikiService
+from iatoolkit.common.access import ADMIN
 
 
 class MemoryWikiService:
@@ -223,7 +224,8 @@ def _read_schema_template(path: str) -> str:
         return ""
 
 
-# Memoria's wiki opens in the wiki viewer for admin and owner only ("Ver como wiki",
-# BL-014); for every other role, and for the wiki tools and MCP, it stays hidden.
-TenantWikiService.register_system_wiki_readers(MemoryWikiService.SYSTEM_OWNER, {"admin", "owner"})
+# Memoria's wiki opens in the wiki viewer only for those who administer the company
+# ("Ver como wiki", BL-014); for everyone else, and for the wiki tools and MCP, it
+# stays hidden.
+TenantWikiService.register_system_wiki_readers(MemoryWikiService.SYSTEM_OWNER, ADMIN)
 

{iatoolkit-2.70.0 → iatoolkit-2.71.1}/src/iatoolkit/services/profile_service.py

@@ -28,6 +28,7 @@ from typing import List, Dict
 from sqlalchemy import update
 from iatoolkit.common.interfaces.signup_policy_resolver import SignupPolicyResolver
 from iatoolkit.services.signup_policy_resolver import AllowAllSignupPolicyResolver
+from iatoolkit.common import access
 
 
 class ProfileService:
@@ -107,6 +108,10 @@ class ProfileService:
         return first_name, last_name
 
     def _build_session_user_profile(self, user: User, company: Company, user_role: str | None) -> dict:
+        if access.Access.registered():
+            # What the person can do over the company (BL-010, Fase 1), for screens and
+            # prompt context; access is always decided with `access.can`.
+            user_role = access.effective_role(company.short_name, user.email)
         auth_method = str(getattr(user, "auth_method", "local") or "local").lower()
         is_local = auth_method == "local"
         user_identifier = user.email
@@ -150,6 +155,7 @@ class ProfileService:
             )
             .values(role="admin")
         )
+        access.role_assigned(company.short_name, user_email, "admin")
 
         updated_params = dict(params)
         updated_params.pop("bootstrap_admin_email", None)
@@ -430,7 +436,8 @@ class ProfileService:
             "last_name": user.last_name if user else "",
             "full_name": f"{user.first_name} {user.last_name}" if user else profile.get("user_fullname", ""),
             "email": profile.get("user_email") or session_info["user_identifier"],
-            "role": profile.get("user_role") or "user",
+            "role": (access.effective_role(company_short_name, session_info["user_identifier"])
+                     if access.Access.registered() else profile.get("user_role")) or "user",
             "auth_method": method,
             "can_edit_name": bool(user and method == "local"),
             "language": self.lang_service.get_current_language(),
@@ -952,8 +959,11 @@ class ProfileService:
         # get the company users from the repo
         company_users =  self.profile_repo.get_company_users_with_details(company_short_name)
 
+        effective = access.effective_roles(company_short_name, [u.email for u, _, _ in company_users]) \
+            if access.Access.registered() else {}
         users_data = []
         for user, role, last_access in company_users:
+            role = effective.get(user.email, role) if access.Access.registered() else role
             users_data.append({
                 "first_name": user.first_name,
                 "last_name": user.last_name,

{iatoolkit-2.70.0 → iatoolkit-2.71.1}/src/iatoolkit/services/prompt_service.py

@@ -25,6 +25,7 @@ from iatoolkit.services.structured_output_service import StructuredOutputService
 import logging
 import re
 import unicodedata
+from iatoolkit.common import access
 
 class PromptService:
     PROMPT_NAME_MAX_LENGTH = 255
@@ -654,7 +655,8 @@ class PromptService:
 
         return normalized_options
 
-    def get_prompts(self, company_short_name: str, include_all: bool = False) -> dict:
+    def get_prompts(self, company_short_name: str, include_all: bool = False,
+                    user_identifier: str | None = None) -> dict:
         try:
             # validate company
             company = self.profile_repo.get_company_by_short_name(company_short_name)
@@ -677,6 +679,10 @@ class PromptService:
                         self.get_runtime_policy_role(getattr(prompt, 'runtime_policy', None))
                     )
                 ]
+                if user_identifier:
+                    # A person sees the agents they may use (BL-010, Fase 1).
+                    all_prompts = [prompt for prompt in all_prompts
+                                   if access.can(company_short_name, user_identifier, access.USE, "agent", prompt.name)]
 
             # group by category
             prompts_by_category = defaultdict(list)

{iatoolkit-2.70.0 → iatoolkit-2.71.1}/src/iatoolkit/services/query_service.py

@@ -25,6 +25,7 @@ import time
 import json
 import re
 from dataclasses import dataclass
+from iatoolkit.common import access
 
 
 @dataclass
@@ -1512,6 +1513,12 @@ class QueryService:
                 return {"error": True,
                         "error_message": self.i18n_service.t('services.start_query')}
 
+            # Using an agent is a level-1 permission over it (BL-010, Fase 1): the chat,
+            # the API and MCP all run through here.
+            if prompt_name and not access.can(company_short_name, user_identifier, access.USE, "agent", prompt_name):
+                return {"error": True, "status_code": 403,
+                        "error_message": self.i18n_service.t('errors.access.agent_denied', prompt_name=prompt_name)}
+
             # output contract
             prompt_output_contract = self._resolve_prompt_output_contract(company, prompt_name)
             log_stage("prompt_output_contract")

{iatoolkit-2.70.0 → iatoolkit-2.71.1}/src/iatoolkit/services/tenant_wiki_service.py

@@ -32,6 +32,7 @@ from iatoolkit.repositories.models import (
 from iatoolkit.repositories.profile_repo import ProfileRepo
 from iatoolkit.services.markdown_wiki_service import MarkdownWikiService
 from iatoolkit.services.storage_service import StorageService
+from iatoolkit.common import access
 
 
 class TenantWikiService:
@@ -120,29 +121,29 @@ class TenantWikiService:
     def is_system_wiki(cls, wiki: KnowledgeWiki | None) -> bool:
         return cls.wiki_system_owner(wiki) is not None
 
-    # Roles that may read a system wiki in the browser viewer, by owning feature
-    # (BL-014: Memoria's wiki for admin and owner). Only the viewer asks: the
-    # wiki tools, MCP resources and reader links keep leaving system wikis out.
-    _system_wiki_reader_roles: dict[str, frozenset[str]] = {}
+    # The level over the company a person needs to read a system wiki in the
+    # browser viewer, by owning feature (BL-014: Memoria's wiki for those who
+    # administer the company). Only the viewer asks: the wiki tools, MCP
+    # resources and reader links keep leaving system wikis out.
+    _system_wiki_reader_levels: dict[str, int] = {}
 
     @classmethod
-    def register_system_wiki_readers(cls, system_owner: str, roles) -> None:
+    def register_system_wiki_readers(cls, system_owner: str, level: int) -> None:
         owner = str(system_owner or "").strip()
         if owner:
-            cls._system_wiki_reader_roles[owner] = frozenset(
-                str(role or "").strip().lower() for role in (roles or ()) if str(role or "").strip())
+            cls._system_wiki_reader_levels[owner] = int(level)
 
-    def viewer_may_read_system_wiki(self, company_short_name: str, wiki_key: str, user_role: str | None) -> bool:
-        """Whether this role may open this system wiki in the viewer; False for a wiki that is not a system wiki."""
-        role = str(user_role or "").strip().lower()
-        if not role:
+    def viewer_may_read_system_wiki(self, company_short_name: str, wiki_key: str, user_identifier: str | None) -> bool:
+        """Whether this person may open this system wiki in the viewer; False for a wiki that is not a system wiki."""
+        if not user_identifier:
             return False
         company = self._get_company(company_short_name)
         if not company:
             return False
         wiki = self.knowledge_wiki_repo.get_wiki_by_key(company.id, self.normalize_wiki_key(wiki_key))
         owner = self.wiki_system_owner(wiki)
-        return bool(owner) and role in self._system_wiki_reader_roles.get(owner, frozenset())
+        level = self._system_wiki_reader_levels.get(owner) if owner else None
+        return level is not None and access.can(company_short_name, user_identifier, level, "company")
 
     def ensure_system_wiki(
         self,