iatoolkit 2.71.1__tar.gz → 2.72.0__tar.gz

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

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

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

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

{iatoolkit-2.71.1 → iatoolkit-2.72.0}/src/iatoolkit/common/access.py

@@ -176,6 +176,22 @@ def role_assigned(company_short_name: str, user_identifier: str, role: str) -> N
                             company_short_name, exc)
 
 
+def filter_llm_models(company_short_name: str, user_identifier: str | None, default_model: str | None,
+                      models: list[dict]) -> tuple[str | None, list[dict]]:
+    """The chat's model choice limited to the models this person may use (BL-010, Fase 2).
+
+    When the company's default is not among them, the first one they may use becomes
+    their default."""
+    if not user_identifier or not Access.registered():
+        return default_model, models
+    allowed = [m for m in models or [] if can(company_short_name, user_identifier, USE, "model",
+                                              str((m or {}).get("id") or ""))]
+    allowed_ids = [str(m.get("id")) for m in allowed]
+    if default_model and default_model not in allowed_ids:
+        default_model = allowed_ids[0] if allowed_ids else None
+    return default_model, allowed
+
+
 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.

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

@@ -695,6 +695,54 @@ ui:
     access_all_resources: "every resource"
     access_company: "the company"
     access_title: "Access"
+    access_person_title: "What this person sees"
+    access_group_title: "What this group can do"
+    access_person_company: "Over the company"
+    access_person_none: "No resource has its own access yet: they use what the whole company uses."
+    access_group_none: "Not listed in any resource's access."
+    access_no_access: "no access"
+    access_role_owner: "Owner"
+    access_role_admin: "Administers"
+    access_role_editor: "Edits"
+    access_role_user: "Uses"
+    access_simulator: "Simulate access"
+    access_simulator_hint: "Pick a person and a resource: it tells you whether they can, and why."
+    access_sim_person: "Person"
+    access_sim_type: "Resource type"
+    access_sim_key: "Resource (name or key)"
+    access_sim_run: "Simulate"
+    access_sim_allowed: "Can"
+    access_sim_denied: "Cannot"
+    access_sim_groups: "Their groups"
+    access_reason_owner: "Owns the company: can do everything."
+    access_reason_company_admin: "Administers the company: administers every resource."
+    access_reason_company: "By their level over the company."
+    access_reason_own_access_list: "The resource has its own list: it depends on whether one of their groups is in it."
+    access_reason_type_default: "The resource uses the company's access for its type."
+    access_export: "Export"
+    access_import: "Import permissions"
+    access_import_hint: "Paste an exported YAML. Check what would change first, then apply it."
+    access_import_check: "Check changes"
+    access_import_apply: "Apply"
+    access_import_groups_created: "New groups"
+    access_import_groups_updated: "Changed groups"
+    access_import_members_added: "Members added"
+    access_import_members_removed: "Members removed"
+    access_import_resources_set: "Resources with their access"
+    access_import_errors: "Errors"
+    access_import_nothing: "Nothing to change."
+    access_import_done: "Permissions imported."
+    access_type_agent: "Agent"
+    access_type_tool: "Tool"
+    access_type_model: "Model"
+    access_type_sql_source: "SQL source"
+    access_type_rag_collection: "Collection"
+    access_type_memory_folder: "Memory folder"
+    access_type_knowledge_wiki: "Wiki"
+    access_type_knowledge_table: "Knowledge table"
+    access_type_mcp_tool: "MCP tool"
+    access_type_company: "The company"
+    access_settings_tab: "Settings"
     access_group_owners: "Owners"
     access_group_admins: "Administrators"
     access_group_editors: "Editors"
@@ -725,6 +773,13 @@ ui:
     access_mode_own: "Restricted"
     access_mode_default: "Whole company"
     access_heading_agent: "Who can use this agent?"
+    access_heading_tool: "Who can use this tool?"
+    access_heading_sql_source: "Who can query this SQL source?"
+    access_heading_knowledge_table: "Who can query this table?"
+    access_heading_model: "Who can use this model?"
+    access_heading_knowledge_wiki: "Who can see this wiki?"
+    access_heading_rag_collection: "Who can see this collection?"
+    access_heading_memory_folder: "Who can see this folder?"
     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."
@@ -837,7 +892,7 @@ ui:
     mode_external_sync: "External"
     mode_managed_help: "The wiki is edited from this workspace and pages are saved into storage."
     mode_external_sync_help: "The wiki stays read-only in IAToolkit and updates from the configured storage root."
-    access_control: "Access control"
+    access_control: "Page visibility by labels"
     access_mode_off: "Off"
     access_mode_off_help: "Access labels are stored but no page is filtered."
     access_mode_dry_run: "Dry run"
@@ -2693,6 +2748,7 @@ 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}."
+    model_denied: "You do not have access to the model {model}."
   timeout: "timeout expired."
   auth:
     invalid_password: "The provided password is incorrect."

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

@@ -709,6 +709,54 @@ ui:
     access_all_resources: "todos los recursos"
     access_company: "la empresa"
     access_title: "Acceso"
+    access_person_title: "Qué ve esta persona"
+    access_group_title: "Qué puede este grupo"
+    access_person_company: "Sobre la empresa"
+    access_person_none: "Ningún recurso tiene acceso propio todavía: usa lo de toda la empresa."
+    access_group_none: "No aparece en la lista de acceso de ningún recurso."
+    access_no_access: "sin acceso"
+    access_role_owner: "Dueño"
+    access_role_admin: "Administra"
+    access_role_editor: "Edita"
+    access_role_user: "Usa"
+    access_simulator: "Simular acceso"
+    access_simulator_hint: "Elige una persona y un recurso: te dice si puede y por qué."
+    access_sim_person: "Persona"
+    access_sim_type: "Tipo de recurso"
+    access_sim_key: "Recurso (nombre o clave)"
+    access_sim_run: "Simular"
+    access_sim_allowed: "Puede"
+    access_sim_denied: "No puede"
+    access_sim_groups: "Sus grupos"
+    access_reason_owner: "Es dueño de la empresa: puede todo."
+    access_reason_company_admin: "Administra la empresa: administra todos los recursos."
+    access_reason_company: "Según su nivel sobre la empresa."
+    access_reason_own_access_list: "El recurso tiene lista propia: decide si alguno de sus grupos está en ella."
+    access_reason_type_default: "El recurso usa el acceso de la empresa para su tipo."
+    access_export: "Exportar"
+    access_import: "Importar permisos"
+    access_import_hint: "Pega un YAML exportado. Primero revisa qué cambiaría y después aplícalo."
+    access_import_check: "Revisar cambios"
+    access_import_apply: "Aplicar"
+    access_import_groups_created: "Grupos nuevos"
+    access_import_groups_updated: "Grupos modificados"
+    access_import_members_added: "Miembros que se agregan"
+    access_import_members_removed: "Miembros que se quitan"
+    access_import_resources_set: "Recursos con su acceso"
+    access_import_errors: "Errores"
+    access_import_nothing: "No hay nada que cambiar."
+    access_import_done: "Permisos importados."
+    access_type_agent: "Agente"
+    access_type_tool: "Tool"
+    access_type_model: "Modelo"
+    access_type_sql_source: "Fuente SQL"
+    access_type_rag_collection: "Colección"
+    access_type_memory_folder: "Carpeta de Memoria"
+    access_type_knowledge_wiki: "Wiki"
+    access_type_knowledge_table: "Knowledge table"
+    access_type_mcp_tool: "Tool MCP"
+    access_type_company: "La empresa"
+    access_settings_tab: "Configuración"
     access_group_owners: "Dueños"
     access_group_admins: "Administradores"
     access_group_editors: "Editores"
@@ -739,6 +787,13 @@ ui:
     access_mode_own: "Restringido"
     access_mode_default: "Toda la empresa"
     access_heading_agent: "¿Quién puede usar este agente?"
+    access_heading_tool: "¿Quién puede usar esta tool?"
+    access_heading_sql_source: "¿Quién puede consultar esta fuente SQL?"
+    access_heading_knowledge_table: "¿Quién puede consultar esta tabla?"
+    access_heading_model: "¿Quién puede usar este modelo?"
+    access_heading_knowledge_wiki: "¿Quién puede ver esta wiki?"
+    access_heading_rag_collection: "¿Quién puede ver esta colección?"
+    access_heading_memory_folder: "¿Quién puede ver esta carpeta?"
     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."
@@ -851,7 +906,7 @@ ui:
     mode_external_sync: "Externa"
     mode_managed_help: "La wiki se edita desde esta interfaz y guarda sus páginas en storage."
     mode_external_sync_help: "La wiki queda de solo lectura en IAToolkit y se actualiza desde la raíz storage configurada."
-    access_control: "Control de acceso"
+    access_control: "Visibilidad de páginas por etiquetas"
     access_mode_off: "Desactivado"
     access_mode_off_help: "Las etiquetas de acceso se guardan pero no se filtra ninguna página."
     access_mode_dry_run: "Simulación"
@@ -2708,6 +2763,7 @@ errors:
   company_not_found: "La empresa {company_short_name} no existe."
   access:
     agent_denied: "No tienes acceso al agente {prompt_name}."
+    model_denied: "No tienes acceso al modelo {model}."
   timeout: "El tiempo de espera ha expirado."
 
 

{iatoolkit-2.71.1 → iatoolkit-2.72.0}/src/iatoolkit/services/company_context_service.py

@@ -52,6 +52,7 @@ class CompanyContextService:
         include_sql_context: bool = True,
         include_yaml_context: bool = True,
         selected_context_files: List[str] | None = None,
+        allowed_databases: List[str] | None = None,
     ) -> dict[str, str]:
         """
         Builds the full context by aggregating three sources:
@@ -78,7 +79,9 @@ class CompanyContextService:
         # schema expansion and expose SQL through dedicated schema/query tools.
         if include_sql_context:
             try:
-                sql_context, db_tables = self._get_sql_enriched_context(company_short_name)
+                # allowed_databases: the sources this person may query (BL-010); None is all.
+                sql_context, db_tables = self._get_sql_enriched_context(company_short_name,
+                                                                        allowed_databases=allowed_databases)
                 sql_context = sql_context.strip()
                 sql_source_table_scopes = self._get_sql_source_table_scopes(company_short_name)
             except Exception as e:

{iatoolkit-2.71.1 → iatoolkit-2.72.0}/src/iatoolkit/services/context_builder_service.py

@@ -199,7 +199,7 @@ class ContextBuilderService:
 
         # 1. Get user profile
         user_profile = self.profile_service.get_profile_by_identifier(company_short_name, user_identifier)
-        available_tools = self.tool_service.get_tools_for_llm(company)
+        available_tools = self.tool_service.get_tools_for_llm(company, user_identifier=user_identifier)
 
         # 2. Render the base system prompt (iatoolkit standard)
         system_prompt_payload = self.prompt_service.get_system_prompt_payload(
@@ -223,9 +223,13 @@ class ContextBuilderService:
             service_list=available_tools,
         )
 
-        # 3. Get company specific context (DB Schemas, Docs, etc.)
-        company_context_blocks = self.company_context_service.get_company_context_blocks(company_short_name)
-        collection_context = self._build_collection_context(company_short_name)
+        # 3. Get company specific context (DB Schemas, Docs, etc.), limited to the SQL
+        # sources and collections this person may use (BL-010, Fase 2).
+        allowed_databases, allowed_collections = self._access_restrictions(company_short_name, user_identifier)
+        company_context_blocks = self.company_context_service.get_company_context_blocks(
+            company_short_name, allowed_databases=allowed_databases)
+        collection_context = "" if allowed_collections == [] else self._build_collection_context(
+            company_short_name, collection_names=allowed_collections)
 
         final_system_context = self._join_context_sections(
             rendered_sections.get("identity"),
@@ -274,6 +278,24 @@ class ContextBuilderService:
 
         return capabilities
 
+    def _access_restrictions(self, company_short_name: str,
+                             user_identifier: str | None) -> tuple[list[str] | None, list[str] | None]:
+        """(SQL sources, collections) this person may use; None where nothing is restricted."""
+        from iatoolkit.common import access
+        if not user_identifier or not access.Access.registered():
+            return None, None
+        from iatoolkit import current_iatoolkit
+        from iatoolkit.services.resource_access_scope import ResourceAccessScope
+        from iatoolkit.services.sql_source_service import SqlSourceService
+        injector = current_iatoolkit().get_injector()
+        scope = injector.get(ResourceAccessScope)
+        databases = [str(s.get("database") or "") for s in
+                     injector.get(SqlSourceService).list_sources(company_short_name, include_inactive=False) or []
+                     if s.get("database")]
+        allowed_databases = scope.allowed_databases(company_short_name, user_identifier, databases)
+        return (None if len(allowed_databases) == len(databases) else allowed_databases,
+                scope.allowed_collections(company_short_name, user_identifier))
+
     def build_agent_system_context(
         self,
         company_short_name: str,
@@ -312,6 +334,12 @@ class ContextBuilderService:
             resource_bindings,
             PromptResourceType.RAG_COLLECTION.value,
         )
+        # The agent's sources and collections, minus those this person may not use.
+        allowed_databases, allowed_collections = self._access_restrictions(company_short_name, user_identifier)
+        if allowed_databases is not None:
+            sql_sources = [s for s in sql_sources if s in allowed_databases]
+        if allowed_collections is not None:
+            rag_collections = [c for c in rag_collections if c in allowed_collections]
 
         prompt_capabilities = self._resolve_system_prompt_capabilities(enabled_tools)
         if self.SQL_TOOL_NAME in enabled_tool_names and not sql_sources:
@@ -370,6 +398,7 @@ class ContextBuilderService:
         company_context_policy = context_policy.get("company_context_blocks") or {}
         company_context_blocks = self.company_context_service.get_company_context_blocks(
             company_short_name,
+            allowed_databases=allowed_databases,
             include_sql_context=bool(company_context_policy.get("sql_context")),
             include_yaml_context=bool(company_context_policy.get("yaml_context")),
         )

{iatoolkit-2.71.1 → iatoolkit-2.72.0}/src/iatoolkit/services/dispatcher_service.py

@@ -56,6 +56,23 @@ class Dispatcher:
         self._company_instances = None
         self._company_instances_revision = -1
 
+    @staticmethod
+    def _scope_tool_call(company_short_name: str, function_name: str, user_identifier: str | None,
+                         kwargs: dict) -> dict:
+        from iatoolkit.common import access
+        if not user_identifier or not access.Access.registered():
+            # No person (internal runs), or no groups (core alone): nothing is restricted.
+            return kwargs
+        from iatoolkit import current_iatoolkit
+        from iatoolkit.services.resource_access_scope import ResourceAccessScope
+        try:
+            injector = current_iatoolkit().get_injector()
+        except Exception:
+            # No running IAToolkit (unit tests of the dispatcher alone): nothing to scope with.
+            return kwargs
+        scope = injector.get(ResourceAccessScope)
+        return scope.scope_tool_call(company_short_name, function_name, user_identifier, kwargs)
+
     def _safe_rollback(self):
         """
         Best-effort rollback for the shared scoped session used by repositories.
@@ -228,6 +245,9 @@ class Dispatcher:
             )
             return result
         try:
+            # What the person may reach (BL-010, Fase 2): the tool, and the SQL source,
+            # collections or wikis the call names or would search.
+            kwargs = self._scope_tool_call(company_short_name, function_name, user_identifier, kwargs)
             result = self._dispatch_resolved_tool(
                 company_short_name=company_short_name,
                 function_name=function_name,

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

@@ -1269,7 +1269,7 @@ class QueryService:
         if not prompt_output_contract:
             return {'rebuild_needed': True, 'error': f"Prompt '{prompt_name}' not found"}
 
-        tools = self.tool_service.get_tools_for_llm(company)
+        tools = self.tool_service.get_tools_for_llm(company, user_identifier=user_identifier)
         is_agent_execution = self._is_agentic_execution(prompt_output_contract)
         tools, _tool_router_metrics = self._apply_prompt_tool_policy(
             company_short_name=company_short_name,
@@ -1528,6 +1528,11 @@ class QueryService:
                 prompt_output_contract=prompt_output_contract,
             )
             effective_model = self._resolve_model(company_short_name, model, prompt_output_contract)
+            # Using a model is a level-1 permission over it (BL-010, Fase 2).
+            if effective_model and not access.can(company_short_name, user_identifier, access.USE, "model",
+                                                  effective_model):
+                return {"error": True, "status_code": 403,
+                        "error_message": self.i18n_service.t('errors.access.model_denied', model=effective_model)}
             output_schema = self._build_output_text_schema_payload(
                 company_short_name,
                 effective_model,
@@ -1616,7 +1621,7 @@ class QueryService:
             is_agent_execution = self._is_agentic_execution(prompt_output_contract) and not is_agent_session_execution
 
             # get the tools availables for this company
-            tools = self.tool_service.get_tools_for_llm(company)
+            tools = self.tool_service.get_tools_for_llm(company, user_identifier=user_identifier)
             log_stage("load_tools")
             tools, tool_router_metrics = self._apply_prompt_tool_policy(
                 company_short_name=company_short_name,
@@ -1920,7 +1925,7 @@ class QueryService:
                 )
 
             is_agent_execution = self._is_agentic_execution(prompt_output_contract)
-            tools = self.tool_service.get_tools_for_llm(company)
+            tools = self.tool_service.get_tools_for_llm(company, user_identifier=user_identifier)
             tools, tool_router_metrics = self._apply_prompt_tool_policy(
                 company_short_name=company_short_name,
                 prompt_output_contract=prompt_output_contract,
@@ -2060,7 +2065,7 @@ class QueryService:
             effective_model = self._resolve_model(company_short_name, None, {})
             provider = self._get_provider(company_short_name, effective_model)
             history_type = self._get_history_type(company_short_name, effective_model)
-            tools = self.tool_service.get_tools_for_llm(company)
+            tools = self.tool_service.get_tools_for_llm(company, user_identifier=user_identifier)
             runtime_context, _user_profile, selected_system_prompt_keys = self.context_builder.build_system_context(
                 company_short_name,
                 user_identifier,

iatoolkit-2.72.0/src/iatoolkit/services/resource_access_scope.py

@@ -0,0 +1,161 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+"""What a tool call may reach, for the person it runs for (BL-010, Fase 2).
+
+Every tool call goes through the dispatcher (chat, API, async tasks, MCP
+projected tools). Before the tool runs, this scopes the call to the resources
+the person may use:
+
+- the tool itself (level 1 over "tool", by its name);
+- the SQL source a query names (`database_key`);
+- the RAG collections a document search names; with none named, the search is
+  narrowed to the collections the person may see (it no longer reaches all);
+- the document a read asks for, by its collection;
+- the wikis a wiki tool names; a search over every wiki is narrowed likewise.
+
+A resource the person may not use raises PERMISSION. A call with no person
+(pipelines, packs: internal runs) is not scoped. Without groups (core alone, or
+nothing restricted) every check passes and the call is unchanged.
+"""
+
+from __future__ import annotations
+
+from injector import inject
+from sqlalchemy import select
+
+from iatoolkit.common import access
+from iatoolkit.common.access import USE
+from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.repositories.database_manager import DatabaseManager
+from iatoolkit.repositories.models import CollectionType, Company, Document, KnowledgeWiki
+
+SQL_TOOLS = frozenset({"iat_sql_query"})
+COLLECTION_TOOLS = frozenset({"iat_document_search", "iat_document_list", "iat_image_search", "iat_visual_search"})
+DOCUMENT_READ_TOOLS = frozenset({"iat_document_read"})
+WIKI_TOOLS = frozenset({"iat_wiki_search", "iat_wiki_get_page"})
+# Collection tools that accept a list of collections; the others take one.
+MULTI_COLLECTION_TOOLS = frozenset({"iat_document_search"})
+
+
+class ResourceAccessScope:
+    @inject
+    def __init__(self, db_manager: DatabaseManager):
+        self.db_manager = db_manager
+
+    @property
+    def session(self):
+        return self.db_manager.get_session()
+
+    # ---------------------------------------------------------------- tool calls
+    def scope_tool_call(self, company_short_name: str, function_name: str, user_identifier: str | None,
+                        arguments: dict) -> dict:
+        """The call's arguments, narrowed to what the person may reach; raises PERMISSION otherwise."""
+        if not user_identifier:
+            return arguments
+        if not access.can(company_short_name, user_identifier, USE, "tool", function_name):
+            raise _denied(f"No access to the tool '{function_name}'.")
+
+        scoped = dict(arguments)
+        if function_name in SQL_TOOLS:
+            database = str(scoped.get("database_key") or "").strip()
+            if database and not access.can(company_short_name, user_identifier, USE, "sql_source", database):
+                raise _denied(f"No access to the SQL source '{database}'.")
+
+        elif function_name in COLLECTION_TOOLS:
+            named = _as_list(scoped.get("collection"))
+            if named:
+                denied = [c for c in named if not self._can_see_collection(company_short_name, user_identifier, c)]
+                if denied:
+                    raise _denied(f"No access to the collection '{denied[0]}'.")
+            else:
+                allowed = self.allowed_collections(company_short_name, user_identifier)
+                if allowed is not None:
+                    # Everything the person may see, never the whole corpus.
+                    if not allowed:
+                        raise _denied("No access to any document collection.")
+                    if function_name in MULTI_COLLECTION_TOOLS:
+                        scoped["collection"] = allowed
+                    elif len(allowed) == 1:
+                        scoped["collection"] = allowed[0]
+                    else:
+                        # These tools take one collection: someone who sees only some names one.
+                        raise _denied("Name the collection: you can see only some of them.")
+
+        elif function_name in DOCUMENT_READ_TOOLS:
+            collection = self._document_collection(company_short_name, scoped.get("document_id"))
+            if collection and not self._can_see_collection(company_short_name, user_identifier, collection):
+                raise _denied("No access to that document.")
+
+        elif function_name in WIKI_TOOLS:
+            wiki_key = str(scoped.get("wiki_key") or "").strip()
+            if wiki_key:
+                if not access.can(company_short_name, user_identifier, USE, "knowledge_wiki", wiki_key):
+                    raise _denied(f"No access to the wiki '{wiki_key}'.")
+            else:
+                allowed = self.allowed_wiki_keys(company_short_name, user_identifier)
+                if allowed is not None:
+                    requested = _as_list(scoped.get("allowed_wiki_keys"))
+                    scoped["allowed_wiki_keys"] = [k for k in allowed if not requested or k in requested]
+        return scoped
+
+    # ------------------------------------------------------------------- listings
+    def allowed_collections(self, company_short_name: str, user_identifier: str | None) -> list[str] | None:
+        """The collections the person may see, or None when nothing is restricted for them."""
+        names = self._collection_names(company_short_name)
+        allowed = [n for n in names if self._can_see_collection(company_short_name, user_identifier, n)]
+        return None if len(allowed) == len(names) else allowed
+
+    def allowed_wiki_keys(self, company_short_name: str, user_identifier: str | None) -> list[str] | None:
+        keys = self._wiki_keys(company_short_name)
+        allowed = [k for k in keys if access.can(company_short_name, user_identifier, USE, "knowledge_wiki", k)]
+        return None if len(allowed) == len(keys) else allowed
+
+    def allowed_databases(self, company_short_name: str, user_identifier: str | None,
+                          databases: list[str]) -> list[str]:
+        return [d for d in databases if access.can(company_short_name, user_identifier, USE, "sql_source", d)]
+
+    def _can_see_collection(self, company_short_name: str, user_identifier: str | None, collection: str) -> bool:
+        return access.can(company_short_name, user_identifier, USE, "rag_collection", collection)
+
+    def _company_id(self, company_short_name: str) -> int | None:
+        return self.session.execute(select(Company.id).where(Company.short_name == company_short_name)).scalar()
+
+    def _collection_names(self, company_short_name: str) -> list[str]:
+        company_id = self._company_id(company_short_name)
+        if company_id is None:
+            return []
+        return [str(n) for n in self.session.execute(
+            select(CollectionType.name).where(CollectionType.company_id == company_id)).scalars()]
+
+    def _wiki_keys(self, company_short_name: str) -> list[str]:
+        company_id = self._company_id(company_short_name)
+        if company_id is None:
+            return []
+        return [str(k) for k in self.session.execute(
+            select(KnowledgeWiki.wiki_key).where(KnowledgeWiki.company_id == company_id)).scalars()]
+
+    def _document_collection(self, company_short_name: str, document_id) -> str | None:
+        try:
+            doc_id = int(document_id)
+        except (TypeError, ValueError):
+            return None
+        return self.session.execute(
+            select(CollectionType.name)
+            .join(Document, Document.collection_type_id == CollectionType.id)
+            .join(Company, Company.id == Document.company_id)
+            .where(Document.id == doc_id, Company.short_name == company_short_name)
+        ).scalar()
+
+
+def _as_list(value) -> list[str]:
+    if value is None:
+        return []
+    values = value if isinstance(value, (list, tuple, set)) else [value]
+    return [str(v).strip() for v in values if str(v or "").strip()]
+
+
+def _denied(message: str) -> IAToolkitException:
+    return IAToolkitException(IAToolkitException.ErrorType.PERMISSION, message)

{iatoolkit-2.71.1 → iatoolkit-2.72.0}/src/iatoolkit/services/tool_service.py

@@ -31,6 +31,7 @@ from iatoolkit.services.system_tools import (
 )
 from iatoolkit.services.tool_output_contract import clone_output_contract, normalize_output_contract
 from iatoolkit import current_iatoolkit
+from iatoolkit.common import access
 
 
 class ToolService:
@@ -1510,9 +1511,11 @@ class ToolService:
 
         return set(required) == set(properties.keys())
 
-    def get_tools_for_llm(self, company: Company) -> list[dict]:
+    def get_tools_for_llm(self, company: Company, user_identifier: str | None = None) -> list[dict]:
         """
         Returns the list of tools (System + Company) formatted for the LLM (OpenAI Schema).
+        With a person, only the tools they may use (BL-010, Fase 2): the model is not
+        offered what the dispatcher would refuse.
         """
         tools = []
 
@@ -1537,6 +1540,9 @@ class ToolService:
 
             tools.append(ai_tool)
 
+        if user_identifier and access.Access.registered():
+            tools = [tool for tool in tools
+                     if access.can(company.short_name, user_identifier, access.USE, "tool", tool["name"])]
         return tools
 
     def get_always_include_tool_names(self, company_short_name: str, tools: list[dict]) -> list[str]:

{iatoolkit-2.71.1 → iatoolkit-2.72.0}/src/iatoolkit/views/base_login_view.py

@@ -18,6 +18,7 @@ from iatoolkit.common.util import Utility
 from iatoolkit.services.jwt_service import JWTService
 from iatoolkit.repositories.models import Company
 import logging
+from iatoolkit.common import access
 
 
 class BaseLoginView(MethodView):
@@ -81,6 +82,8 @@ class BaseLoginView(MethodView):
             # --- FAST PATH: Render the chat page directly ---
             # LLM configuration: default model and availables
             default_llm_model, available_llm_models = self.config_service.get_llm_configuration(company_short_name)
+            default_llm_model, available_llm_models = access.filter_llm_models(
+                company_short_name, user_identifier, default_llm_model, available_llm_models)
             llm_request_defaults = self.config_service.get_llm_request_defaults(company_short_name) or {}
             llm_default_reasoning_effort = str(
                 ((llm_request_defaults.get("reasoning") or {}).get("effort")) or ""

{iatoolkit-2.71.1 → iatoolkit-2.72.0}/src/iatoolkit/views/chat_view.py

@@ -6,6 +6,7 @@ from iatoolkit.services.branding_service import BrandingService
 from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.services.prompt_service import PromptService
 from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.common import access
 
 class ChatView(MethodView):
     """
@@ -48,6 +49,8 @@ class ChatView(MethodView):
             branding_data = self.branding_service.get_company_branding(company_short_name)
             onboarding_cards = self.config_service.get_configuration(company_short_name, 'onboarding_cards')
             default_llm_model, available_llm_models = self.config_service.get_llm_configuration(company_short_name)
+            default_llm_model, available_llm_models = access.filter_llm_models(
+                company_short_name, user_identifier, default_llm_model, available_llm_models)
             llm_request_defaults = self.config_service.get_llm_request_defaults(company_short_name) or {}
             llm_default_reasoning_effort = str(
                 ((llm_request_defaults.get("reasoning") or {}).get("effort")) or ""

{iatoolkit-2.71.1 → iatoolkit-2.72.0}/src/iatoolkit/views/login_view.py

@@ -22,6 +22,7 @@ from iatoolkit.common.util import Utility
 import logging
 import secrets
 from urllib.parse import urljoin, urlparse
+from iatoolkit.common import access
 
 
 def _normalize_safe_next_target(raw_target: str | None) -> str | None:
@@ -487,6 +488,8 @@ class FinalizeContextView(MethodView):
             branding_data = self.branding_service.get_company_branding(company_short_name)
 
             default_llm_model, available_llm_models = self.config_service.get_llm_configuration(company_short_name)
+            default_llm_model, available_llm_models = access.filter_llm_models(
+                company_short_name, user_identifier, default_llm_model, available_llm_models)
             llm_request_defaults = self.config_service.get_llm_request_defaults(company_short_name) or {}
             llm_default_reasoning_effort = str(
                 ((llm_request_defaults.get("reasoning") or {}).get("effort")) or ""

{iatoolkit-2.71.1 → iatoolkit-2.72.0}/src/iatoolkit/views/wiki_page_view.py

@@ -16,6 +16,7 @@ from iatoolkit.services.i18n_service import I18nService
 from iatoolkit.services.markdown_wiki_service import MarkdownWikiService
 from iatoolkit.services.profile_service import ProfileService
 from iatoolkit.services.tenant_wiki_service import TenantWikiService
+from iatoolkit.common import access
 
 
 class WikiPageView(MethodView):
@@ -62,7 +63,11 @@ class WikiPageView(MethodView):
         if self.tenant_wiki_service.viewer_may_read_system_wiki(company_short_name, wiki_key, user_identifier):
             # A system wiki its feature opened to this person (Memoria for company admins).
             page_kwargs["include_system"] = True
-        result = self.tenant_wiki_service.get_page(company_short_name, **page_kwargs)
+        if access.can(company_short_name, user_identifier, access.USE, "knowledge_wiki", wiki_key):
+            result = self.tenant_wiki_service.get_page(company_short_name, **page_kwargs)
+        else:
+            # A wiki this person may not see (BL-010, Fase 2).
+            result = {"status": TenantWikiService.ACCESS_STATUS_FORBIDDEN}
         wiki = result.get("wiki") or {}
         context = {
             "company_short_name": company_short_name,