iatoolkit 2.42.0__tar.gz → 2.43.0__tar.gz

{iatoolkit-2.42.0/src/iatoolkit.egg-info → iatoolkit-2.43.0}/PKG-INFO

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

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/__init__.py

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

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/common/model_registry.py

@@ -60,6 +60,10 @@ class RouteParam:
     is_env_name: bool = False
     #: A regular expression the value must match, or None for "any non-empty".
     pattern: str | None = None
+    #: How to finish "'base_url' does not look like ___" when the pattern refuses a
+    #: value. Declared here so a new parameter cannot inherit another one's wording:
+    #: the message for `model_name` read "does not look like a URL".
+    looks_like: str = "a valid value"
 
 
 #: What each provider needs in order to be reached, keyed by provider.
@@ -81,14 +85,23 @@ class RouteParam:
 #: `openrouter` allows both and requires neither: there is one OpenRouter for
 #: everyone and its base URL has a working default, so an entry only overrides
 #: when it has a reason to.
+#: `model_name` is optional and exists because a catalogue key is lowercased: it
+#: identifies the model across entitlements, rate cards and usage rows, so it cannot
+#: also be the name on the wire. A vLLM endpoint serving
+#: `meta-llama/Llama-3.1-8B-Instruct` answers 404 to the lowercased key. When set,
+#: it is the exact name that endpoint answers to, and only the wire value changes.
 PROVIDER_ROUTE_PARAMS: dict[str, tuple[RouteParam, ...]] = {
     "openai_compatible": (
-        RouteParam("base_url", required=True, pattern=r"^https?://\S+$"),
-        RouteParam("api_key_env", required=True, is_env_name=True, pattern=r"^[A-Z][A-Z0-9_]*$"),
+        RouteParam("base_url", required=True, pattern=r"^https?://\S+$", looks_like="a URL"),
+        RouteParam("api_key_env", required=True, is_env_name=True, pattern=r"^[A-Z][A-Z0-9_]*$",
+                   looks_like="an environment variable name"),
+        RouteParam("model_name", required=False, pattern=r"^[A-Za-z0-9._:\-/]+$",
+                   looks_like="a model name"),
     ),
     "openrouter": (
-        RouteParam("base_url", required=False, pattern=r"^https?://\S+$"),
-        RouteParam("api_key_env", required=False, is_env_name=True, pattern=r"^[A-Z][A-Z0-9_]*$"),
+        RouteParam("base_url", required=False, pattern=r"^https?://\S+$", looks_like="a URL"),
+        RouteParam("api_key_env", required=False, is_env_name=True, pattern=r"^[A-Z][A-Z0-9_]*$",
+                   looks_like="an environment variable name"),
     ),
 }
 
@@ -163,12 +176,16 @@ class ModelRegistry:
 
     def get_capabilities(self, model: str, provider: str | None = None) -> dict:
         normalized_provider = self.normalize_provider(provider=provider, model=model)
+        # `openai_compatible` is absent on purpose. Its adapter targets any server
+        # that speaks chat.completions — llama.cpp, vLLM, a private gateway — and
+        # forwards no reasoning field, because one the server does not know earns a
+        # 400. Claiming the capability here made the tenant's Models page offer a
+        # reasoning control whose value went nowhere.
         supports_reasoning_effort = normalized_provider in {
             "openai",
             "xai",
             "openrouter",
             "deepseek",
-            "openai_compatible",
         }
         supports_text_verbosity = normalized_provider in {"openai", "xai", "openrouter"}
         supports_store = normalized_provider in {"openai", "xai"}

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/infra/inference_embeddings_client.py

@@ -37,5 +37,21 @@ class InferenceEmbeddingsClient:
         except Exception as e:
             raise RuntimeError(f"Error generando embedding con InferenceClient: {e}")
 
+    def get_embeddings(self, texts: List[str]) -> List[List[float]]:
+        """Embed a batch in one call. feature_extraction accepts a list and
+        returns one row per input; the single-text path already handled that shape."""
+        try:
+            embeddings = self.client.feature_extraction(list(texts))
+            if hasattr(embeddings, "tolist"):
+                embeddings = embeddings.tolist()
+            if not isinstance(embeddings, list) or len(embeddings) != len(texts):
+                raise RuntimeError(
+                    f"feature_extraction returned {len(embeddings) if isinstance(embeddings, list) else 'no'} "
+                    f"rows for {len(texts)} inputs."
+                )
+            return embeddings
+        except Exception as e:
+            raise RuntimeError(f"Error generando embeddings en lote con InferenceClient: {e}")
+
     def get_image_embedding(self, presigned_url: Optional[str] = None, image_bytes: Optional[bytes] = None) -> List[float]:
         raise NotImplementedError("Image embedding not implemented for this client.")

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/infra/inference_handler.py

@@ -192,12 +192,29 @@ class EndpointHandler:
         return {"embedding": vec}
 
     def _handle_text_embedding(self, inputs: dict) -> dict:
-        text = inputs.get("text")
-        if not isinstance(text, str) or not text.strip():
-            raise ValueError("Expected inputs.text for text embedding generation.")
+        """Embed one text or a batch, in the order received.
+
+        ``inputs.text`` (str) returns ``{"embedding": [...]}`` and ``inputs.texts``
+        (list) returns ``{"embeddings": [[...], ...]}``. Both shapes are answered so
+        an endpoint running this handler stays compatible with callers that predate
+        batching. The pooling below was already batch-shaped — it computed (B, D) and
+        returned row 0 — so the batch path is the same maths without the slice.
+        """
+        texts = inputs.get("texts")
+        batched = texts is not None
+        if batched:
+            if not isinstance(texts, list) or not texts:
+                raise ValueError("Expected inputs.texts to be a non-empty list of strings.")
+            if any(not isinstance(item, str) or not item.strip() for item in texts):
+                raise ValueError("Every entry in inputs.texts must be a non-empty string.")
+        else:
+            text = inputs.get("text")
+            if not isinstance(text, str) or not text.strip():
+                raise ValueError("Expected inputs.text for text embedding generation.")
+            texts = [text]
 
         encoded_input = self.processor_instance(
-            text,
+            texts,
             padding=True,
             truncation=True,
             return_tensors='pt'
@@ -213,7 +230,10 @@ class EndpointHandler:
             min=1e-9
         )
         sentence_embeddings = torch.nn.functional.normalize(sentence_embeddings, p=2, dim=1)
-        return {"embedding": sentence_embeddings[0].cpu().tolist()}
+        vectors = sentence_embeddings.cpu().tolist()
+        if batched:
+            return {"embeddings": vectors}
+        return {"embedding": vectors[0]}
 
     # Backward-compatible alias: existing tests/callers may still refer to _handle_minilm
     def _handle_minilm(self, inputs: dict) -> dict:

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/infra/jina_embeddings_client.py

@@ -36,6 +36,23 @@ class JinaEmbeddingsClient:
         response = self._post(payload)
         return response["data"][0]["embedding"]
 
+    def get_embeddings(self, texts: List[str]) -> List[List[float]]:
+        """Embed a batch in one request. The API already took a list; this uses it."""
+        payload = {
+            "model": self.model,
+            "normalized": self.normalized,
+            "embedding_type": "float",
+            "input": list(texts),
+        }
+        response = self._post(payload)
+        data = response["data"]
+        if len(data) != len(texts):
+            raise ValueError(f"Jina returned {len(data)} embeddings for {len(texts)} inputs.")
+        # Sort by the API's own index rather than trusting arrival order: a silent
+        # reordering would attach each vector to the wrong text.
+        ordered = sorted(data, key=lambda item: item.get("index", 0))
+        return [item["embedding"] for item in ordered]
+
     def get_image_embedding(self,
                             presigned_url: Optional[str] = None,
                             image_bytes: Optional[bytes] = None

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/infra/llm_providers/openai_compatible_chat_adapter.py

@@ -22,7 +22,21 @@ class OpenAICompatibleChatAdapter:
     """
 
     supports_multimodal = False
-    supports_reasoning = True
+    #: `reasoning` is a **Responses API** parameter. This class calls
+    #: `chat.completions.create`, whose signature has no such argument, so the
+    #: OpenAI SDK raises a TypeError before any request leaves the process:
+    #: "Completions.create() got an unexpected keyword argument 'reasoning'".
+    #:
+    #: It was True here, and both subclasses overrode it to False — DeepSeek and
+    #: OpenRouter each had to correct the base. Nothing was served by this class
+    #: directly until a model with provider `openai_compatible` was added from the
+    #: catalogue, and that first request crashed.
+    supports_reasoning = False
+    #: The Chat Completions equivalent is the plain string `reasoning_effort`, and
+    #: it stays off *here*: this class targets any OpenAI-compatible server —
+    #: llama.cpp, vLLM, a private gateway — and a server that does not know the
+    #: field answers 400. A provider whose API does accept it opts in, which is
+    #: what DeepseekAdapter does.
     supports_reasoning_effort = False
     supports_reasoning_content_messages = False
     supports_metadata = False

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/infra/llm_proxy.py

@@ -142,7 +142,11 @@ class LLMProxy:
             request_kwargs["telemetry_execution"] = telemetry_execution
 
         # Delegate to the adapter (OpenAI, Gemini, DeepSeek, xAI, Anthropic, etc.)
-        return adapter.create_response(model=model, input=input, **request_kwargs)
+        return adapter.create_response(
+            model=self._wire_model(model, model_config),
+            input=input,
+            **request_kwargs,
+        )
 
     def describe_transport(self, company_short_name: str, model: str) -> str:
         provider = self._resolve_provider_for_company_model(
@@ -349,7 +353,6 @@ class LLMProxy:
                 self.PROVIDER_OPENAI,
                 self.PROVIDER_XAI,
                 self.PROVIDER_DEEPSEEK,
-                self.PROVIDER_OPENAI_COMPATIBLE,
                 self.PROVIDER_OPENROUTER,
             })
         )
@@ -746,6 +749,23 @@ class LLMProxy:
         route = (model_config or {}).get("route_config") if isinstance(model_config, dict) else None
         return dict(route) if isinstance(route, dict) else {}
 
+    @staticmethod
+    def _wire_model(model: str, model_config: Dict[str, Any] | None) -> str:
+        """The name the endpoint itself answers to, which is not always our key.
+
+        Catalogue keys are lowercased on write, because one key identifies a model
+        across entitlements, rate cards and usage rows. A server is free to be
+        case-sensitive: a vLLM endpoint serving `meta-llama/Llama-3.1-8B-Instruct`
+        answers `404 - The model does not exist` to the lowercased key.
+
+        So an entry may carry the exact served name in its route, and only the value
+        on the wire changes. Everything metered stays keyed by the catalogue key,
+        which is what keeps one model from splitting into two usage lines.
+        """
+        route = LLMProxy._model_route(model_config)
+        served_name = str(route.get("model_name") or "").strip()
+        return served_name or model
+
     @staticmethod
     def _model_credential_ref(model_config: Dict[str, Any] | None) -> str | None:
         """The secret this model is entitled to run on, when the company owns it.

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/locales/en.yaml

@@ -1806,6 +1806,17 @@ ui:
     new_modal_title: "Create New Prompt"
     name_label: "Name (Slug)"
     name_help: "Use lowercase, numbers, and underscores only."
+    create_name_label: "Name"
+    create_name_placeholder: "Customer Support"
+    create_name_help: "Used to suggest the technical identifier."
+    create_key_label: "Technical ID"
+    create_key_placeholder: "customer_support"
+    create_key_help: "Stable snake_case identifier used internally."
+    create_name_required: "Name is required."
+    create_key_required: "Technical ID is required."
+    create_creating: "Creating agent..."
+    create_success: "Agent \"{name}\" created."
+    create_failed: "Failed to create the agent."
     category_label: "Category"
     versions_btn: "Versions"
     versions_modal_title: "Previous versions"
@@ -1848,8 +1859,9 @@ ui:
     type_label: "Tool Type"
     method_label: "Execution Method"
     method_help: "Python method name in your company class implementation, or inference tool name."
-    desc_label: "Description (Prompt)"
-    desc_placeholder: "Describe to the LLM when and how to use this tool..."
+    desc_label: "Description for the agent"
+    desc_placeholder: "Describe for the agent when and how to use this tool..."
+    desc_help: "This description guides the agent in deciding when to use this tool."
     active_label: "Active"
 
     # Schema Section
@@ -1877,6 +1889,14 @@ ui:
     modal_title: "Create New Tool"
     modal_name_label: "Tool Name (LLM Function)"
     modal_name_help: "Use snake_case. Must be unique."
+    modal_display_name_label: "Name"
+    modal_display_name_placeholder: "Tax Calculator"
+    modal_display_name_help: "Used to suggest the technical identifier."
+    modal_display_name_required: "Name is required."
+    modal_key_label: "Technical ID"
+    modal_key_placeholder: "calculate_tax"
+    modal_key_help: "Stable snake_case identifier used by prompts and routing."
+    modal_key_required: "Technical ID is required."
     modal_type_label: "Type"
     modal_output_preset_label: "Output preset"
     modal_output_preset_none: "No preset"
@@ -2172,6 +2192,7 @@ ui:
     col_cost: "Cost"
     col_key: "API key"
     col_enabled: "Enabled"
+    col_default: "Default"
     col_reasoning: "Reasoning"
     cost_metered: "Metered"
     cost_not_billable: "No charge"
@@ -2206,6 +2227,8 @@ ui:
     form_route_base_url_hint: "The full URL requests go to, e.g. https://your-host/v1"
     form_route_api_key_env: "Credential variable"
     form_route_api_key_env_hint: "The NAME of an environment variable in this deployment, e.g. OSS_LLM_API_KEY. Never the key itself."
+    form_route_model_name: "Name served by the endpoint"
+    form_route_model_name_hint: "Optional. The exact name this endpoint answers to, e.g. meta-llama/Llama-3.1-8B-Instruct. Leave empty to send the identifier above, which is stored in lowercase."
     route_required: "This provider needs an endpoint and the name of its credential variable."
   secrets:
     title: "Secrets"

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/locales/es.yaml

@@ -1811,6 +1811,17 @@ ui:
     new_modal_title: "Crear Nuevo Prompt"
     name_label: "Nombre (Slug)"
     name_help: "Solo minúsculas, números y guiones bajos."
+    create_name_label: "Nombre"
+    create_name_placeholder: "Soporte al cliente"
+    create_name_help: "Se usa para sugerir el identificador técnico."
+    create_key_label: "ID técnico"
+    create_key_placeholder: "soporte_cliente"
+    create_key_help: "Identificador estable en snake_case usado internamente."
+    create_name_required: "El nombre es obligatorio."
+    create_key_required: "El ID técnico es obligatorio."
+    create_creating: "Creando agente..."
+    create_success: "Agente \"{name}\" creado."
+    create_failed: "No se pudo crear el agente."
     category_label: "Categoría"
     versions_btn: "Versiones"
     versions_modal_title: "Versiones antiguas"
@@ -1854,8 +1865,9 @@ ui:
     type_label: "Tipo de Herramienta"
     method_label: "Método a ejecutar"
     method_help: "Nombre del método Python en la implementación de la clase de su empresa, o nombre de tool en inference"
-    desc_label: "Descripción (Prompt)"
-    desc_placeholder: "Describe al LLM cuándo y cómo usar esta herramienta..."
+    desc_label: "Descripción para el agente"
+    desc_placeholder: "Describe al agente cuándo y cómo usar esta tool..."
+    desc_help: "Esta descripción guía al agente para decidir cuándo usar esta tool."
     active_label: "Activo"
 
     # Schema Section
@@ -1883,6 +1895,14 @@ ui:
     modal_title: "Crear Nueva Herramienta"
     modal_name_label: "Nombre (Función LLM)"
     modal_name_help: "Usar snake_case. Debe ser único."
+    modal_display_name_label: "Nombre"
+    modal_display_name_placeholder: "Calculadora tributaria"
+    modal_display_name_help: "Se usa para sugerir el identificador técnico."
+    modal_display_name_required: "El nombre es obligatorio."
+    modal_key_label: "ID técnico"
+    modal_key_placeholder: "calcular_impuestos"
+    modal_key_help: "Identificador estable en snake_case usado por prompts y routing."
+    modal_key_required: "El ID técnico es obligatorio."
     modal_type_label: "Tipo"
     modal_output_preset_label: "Preset de output"
     modal_output_preset_none: "Sin preset"
@@ -2178,6 +2198,7 @@ ui:
     col_cost: "Costo"
     col_key: "API key"
     col_enabled: "Habilitado"
+    col_default: "Por defecto"
     col_reasoning: "Razonamiento"
     cost_metered: "Con medición"
     cost_not_billable: "Sin costo"
@@ -2212,6 +2233,8 @@ ui:
     form_route_base_url_hint: "La URL completa a la que van las requests, ej. https://tu-host/v1"
     form_route_api_key_env: "Variable de la credencial"
     form_route_api_key_env_hint: "El NOMBRE de una variable de entorno de este deployment, ej. OSS_LLM_API_KEY. Nunca la key."
+    form_route_model_name: "Nombre que sirve el endpoint"
+    form_route_model_name_hint: "Opcional. El nombre exacto al que responde el endpoint, ej. meta-llama/Llama-3.1-8B-Instruct. Vacío envía el identificador de arriba, que se guarda en minúsculas."
     route_required: "Este proveedor necesita un endpoint y el nombre de la variable con su credencial."
   secrets:
     title: "Secrets"

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/repositories/llm_query_repo.py

@@ -66,6 +66,12 @@ class LLMQueryRepo:
             is_active=True
         ).first()
 
+    def get_tool_by_name(self, company: Company, tool_name: str) -> Tool | None:
+        return self.session.query(Tool).filter_by(
+            company_id=company.id,
+            name=tool_name,
+        ).first()
+
     def get_system_tool(self, tool_name: str) -> Tool | None:
         return self.session.query(Tool).filter_by(
             tool_type=Tool.TYPE_SYSTEM,

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/services/embedding_service.py

@@ -34,6 +34,22 @@ class EmbeddingClientWrapper:
         """Generates and returns an embedding for the given text."""
         raise NotImplementedError
 
+    def get_embeddings(self, texts: list[str], suppress_error_logging: bool = False) -> list[list[float]]:
+        """Embeds several texts, returning one vector per input in the same order.
+
+        The default walks the single-text path so every provider works without
+        changes; wrappers whose backend accepts a list override this with one
+        request per batch. Callers must not assume a single round trip.
+        """
+        return [
+            self.get_embedding(text, suppress_error_logging=suppress_error_logging)
+            for text in texts
+        ]
+
+    def supports_batching(self) -> bool:
+        """Whether get_embeddings issues one request per batch instead of per text."""
+        return False
+
     def get_image_embedding(self,
                             presigned_url: Optional[str] = None,
                             image_bytes: Optional[bytes] = None
@@ -71,6 +87,39 @@ class HuggingFaceClientWrapper(EmbeddingClientWrapper):
         )
         return result["embedding"]
 
+    def supports_batching(self) -> bool:
+        # Opt-in per tool: an endpoint still running a handler that predates
+        # inputs.texts would reject the batch payload, so this stays off until the
+        # deployment is confirmed via `supports_batch_embedding: true`.
+        return bool(self._tool_config().get("supports_batch_embedding"))
+
+    def _tool_config(self) -> dict:
+        try:
+            return self.inference_service._get_tool_config(self.company_short_name, self.tool_name) or {}
+        except Exception:
+            logging.debug("Could not read inference tool config for batching.", exc_info=True)
+            return {}
+
+    def get_embeddings(self, texts: list[str], suppress_error_logging: bool = False) -> list[list[float]]:
+        if not self.supports_batching():
+            return super().get_embeddings(texts, suppress_error_logging=suppress_error_logging)
+
+        result = self.inference_service.predict(
+            self.company_short_name,
+            self.tool_name,
+            {"mode": "text", "texts": list(texts)},
+            suppress_error_logging=suppress_error_logging,
+        )
+        embeddings = result.get("embeddings")
+        if not isinstance(embeddings, list) or len(embeddings) != len(texts):
+            # A silent length mismatch would pair each text with the wrong vector,
+            # which no downstream check would catch. Fail instead.
+            raise ValueError(
+                f"Batch embedding returned {len(embeddings) if isinstance(embeddings, list) else 'no'} "
+                f"vectors for {len(texts)} inputs."
+            )
+        return embeddings
+
     def get_image_embedding(self,
                             presigned_url: Optional[str] = None,
                             image_bytes: Optional[bytes] = None
@@ -129,6 +178,24 @@ class OpenAIClientWrapper(EmbeddingClientWrapper):
         response = self.client.embeddings.create(**kwargs)
         return response.data[0].embedding
 
+    def supports_batching(self) -> bool:
+        return True
+
+    def get_embeddings(self, texts: list[str], suppress_error_logging: bool = False) -> list[list[float]]:
+        kwargs = {
+            "input": [text.replace("\n", " ") for text in texts],
+            "model": self.model,
+        }
+        if self.dimensions is not None:
+            kwargs["dimensions"] = self.dimensions
+        response = self.client.embeddings.create(**kwargs)
+        # The API documents input order, but pairing the wrong vector to a text is
+        # invisible downstream, so sort by index rather than trusting arrival order.
+        ordered = sorted(response.data, key=lambda item: item.index)
+        if len(ordered) != len(texts):
+            raise ValueError(f"Batch embedding returned {len(ordered)} vectors for {len(texts)} inputs.")
+        return [item.embedding for item in ordered]
+
 class CustomClassClientWrapper(EmbeddingClientWrapper):
     """
     Adapter for custom embedding classes defined by the user.
@@ -151,6 +218,20 @@ class CustomClassClientWrapper(EmbeddingClientWrapper):
             return embedding[0]
         return embedding
 
+    def supports_batching(self) -> bool:
+        return hasattr(self.client, "get_embeddings")
+
+    def get_embeddings(self, texts: list[str], suppress_error_logging: bool = False) -> list[list[float]]:
+        if not self.supports_batching():
+            return super().get_embeddings(texts, suppress_error_logging=suppress_error_logging)
+        embeddings = self.client.get_embeddings(list(texts))
+        if not isinstance(embeddings, list) or len(embeddings) != len(texts):
+            raise ValueError(
+                f"Batch embedding returned {len(embeddings) if isinstance(embeddings, list) else 'no'} "
+                f"vectors for {len(texts)} inputs."
+            )
+        return embeddings
+
     def get_image_embedding(self,
                             presigned_url: Optional[str] = None,
                             image_bytes: Optional[bytes] = None
@@ -504,6 +585,80 @@ class EmbeddingService:
                 logging.error(f"Error generating embedding for text: {text[:80]}... - {e}")
             raise
 
+    # Batch defaults: 32 texts is a good round trip for short records, and the
+    # character budget guards against a few long findings blowing the payload.
+    DEFAULT_EMBED_BATCH_SIZE = 32
+    DEFAULT_EMBED_BATCH_MAX_CHARS = 40000
+
+    def embed_texts(
+            self,
+            company_short_name: str,
+            texts: list[str],
+            model_type: str = 'text',
+            batch_size: Optional[int] = None,
+            max_chars_per_batch: Optional[int] = None,
+            suppress_error_logging: bool = False,
+    ) -> list[list[float]]:
+        """Embed many texts, returning one vector per input in the same order.
+
+        Resolves the company and the client once instead of once per text, and
+        sends batches when the provider supports them. If a batch fails, its
+        texts are retried one by one so a single bad input cannot lose the rest.
+        """
+        if not texts:
+            return []
+
+        company = self.profile_repo.get_company_by_short_name(company_short_name)
+        if not company:
+            raise ValueError(self.i18n_service.t('errors.company_not_found', company_short_name=company_short_name))
+        client_wrapper = self.client_factory.get_client(company_short_name, model_type)
+
+        size = int(batch_size or self.DEFAULT_EMBED_BATCH_SIZE)
+        char_budget = int(max_chars_per_batch or self.DEFAULT_EMBED_BATCH_MAX_CHARS)
+        embeddings: list[list[float]] = []
+        for batch in self._chunk_texts(texts, size=size, char_budget=char_budget):
+            embeddings.extend(
+                self._embed_batch(
+                    client_wrapper,
+                    batch,
+                    suppress_error_logging=suppress_error_logging,
+                )
+            )
+        if len(embeddings) != len(texts):
+            raise ValueError(f"Embedded {len(embeddings)} vectors for {len(texts)} texts.")
+        return embeddings
+
+    def _embed_batch(self, client_wrapper, batch: list[str], *, suppress_error_logging: bool) -> list[list[float]]:
+        try:
+            return client_wrapper.get_embeddings(batch, suppress_error_logging=suppress_error_logging)
+        except Exception as error:
+            if len(batch) == 1 or not client_wrapper.supports_batching():
+                raise
+            logging.warning(
+                "Batch embedding of %s texts failed (%s); retrying them individually.",
+                len(batch),
+                error,
+            )
+            return [
+                client_wrapper.get_embedding(text, suppress_error_logging=suppress_error_logging)
+                for text in batch
+            ]
+
+    @staticmethod
+    def _chunk_texts(texts: list[str], *, size: int, char_budget: int):
+        """Split by count and by characters, so a few long texts do not oversize a batch."""
+        batch: list[str] = []
+        batch_chars = 0
+        for text in texts:
+            length = len(text or "")
+            if batch and (len(batch) >= size or batch_chars + length > char_budget):
+                yield batch
+                batch, batch_chars = [], 0
+            batch.append(text)
+            batch_chars += length
+        if batch:
+            yield batch
+
     def embed_image(self, company_short_name: str,
                     presigned_url: Optional[str] = None,
                     image_bytes: Optional[bytes] = None) -> list[float]:

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/services/prompt_service.py

@@ -22,8 +22,11 @@ from iatoolkit.common.exceptions import IAToolkitException
 from iatoolkit.services.system_prompt_catalog import build_system_prompt_payload
 from iatoolkit.services.structured_output_service import StructuredOutputService
 import logging
+import re
+import unicodedata
 
 class PromptService:
+    PROMPT_NAME_MAX_LENGTH = 255
     OUTPUT_SCHEMA_MODE_BEST_EFFORT = "best_effort"
     OUTPUT_SCHEMA_MODE_STRICT = "strict"
     OUTPUT_RESPONSE_MODE_CHAT = "chat_compatible"
@@ -76,6 +79,34 @@ class PromptService:
         self.sql_service = sql_service
         self.configuration_service = configuration_service
 
+    @classmethod
+    def normalize_prompt_name(cls, prompt_name: str | None) -> str:
+        candidate = str(prompt_name or "").strip()
+        if not candidate:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.MISSING_PARAMETER,
+                "Prompt name is required",
+            )
+
+        normalized = unicodedata.normalize("NFKD", candidate).encode("ascii", "ignore").decode("ascii")
+        normalized = normalized.lower()
+        normalized = re.sub(r"[^a-z0-9]+", "_", normalized)
+        normalized = re.sub(r"_+", "_", normalized).strip("_")
+
+        if not normalized:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                "Prompt name must contain letters or numbers",
+            )
+
+        if len(normalized) > cls.PROMPT_NAME_MAX_LENGTH:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                f"Prompt name must be {cls.PROMPT_NAME_MAX_LENGTH} characters or fewer",
+            )
+
+        return normalized
+
     def _normalize_execution_mode(
         self,
         execution_mode: str | None,

{iatoolkit-2.42.0 → iatoolkit-2.43.0}/src/iatoolkit/services/query_service.py

@@ -612,7 +612,6 @@ class QueryService:
                 "xai",
                 "openrouter",
                 "deepseek",
-                "openai_compatible",
             ))
         )
         text_verbosity_provider_supported = bool(