iatoolkit 2.6.3__tar.gz → 2.6.4__tar.gz

{iatoolkit-2.6.3/src/iatoolkit.egg-info → iatoolkit-2.6.4}/PKG-INFO

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

{iatoolkit-2.6.3 → iatoolkit-2.6.4}/src/iatoolkit/__init__.py

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

{iatoolkit-2.6.3 → iatoolkit-2.6.4}/src/iatoolkit/common/routes.py

@@ -14,6 +14,7 @@ from iatoolkit.common.exceptions import IAToolkitException
 def register_views(app):
 
     from iatoolkit.views.init_context_api_view import InitContextApiView
+    from iatoolkit.views.invocations_api_view import InvocationsApiView
     from iatoolkit.views.llmquery_api_view import LLMQueryApiView
     from iatoolkit.views.signup_view import SignupView
     from iatoolkit.views.verify_user_view import VerifyAccountView
@@ -108,6 +109,7 @@ def register_views(app):
     # main chat query, used by the JS in the browser (with credentials)
     # can be used also for executing iatoolkit prompts
     app.add_url_rule('/<company_short_name>/api/llm_query', view_func=LLMQueryApiView.as_view('llm_query_api'))
+    app.add_url_rule('/<company_short_name>/api/invocations', view_func=InvocationsApiView.as_view('invocations_api'))
 
     # Categories Endpoint
     app.add_url_rule('/<company_short_name>/api/categories',

{iatoolkit-2.6.3 → iatoolkit-2.6.4}/src/iatoolkit/infra/llm_providers/openai_adapter.py

@@ -34,6 +34,12 @@ class OpenAIAdapter:
                         telemetry_execution: Any = None) -> LLMResponse:
         """Llamada a la API de OpenAI y mapeo a estructura común"""
         try:
+            input = self._normalize_input_items(
+                input_items=input,
+                previous_response_id=previous_response_id,
+                context_history=context_history,
+            )
+
             # Handle multimodal input if images are present
             if images or attachments:
                 input = self._prepare_multimodal_input(input, images or [], attachments or [])
@@ -74,6 +80,128 @@ class OpenAIAdapter:
 
             raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 
+    def _normalize_input_items(
+        self,
+        input_items: Optional[List[Dict]],
+        previous_response_id: Optional[str] = None,
+        context_history: Optional[List[Dict]] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Normalize our internal history format to the subset accepted by Responses API.
+
+        Important cases:
+        - Assistant messages with `tool_calls` must become top-level `function_call` items.
+        - `function_call_output` items must not include internal-only fields such as `status`.
+        - When continuing from a prior response with `previous_response_id`, tool follow-ups
+          should only append the `function_call_output` items because the previous response
+          already contains the originating user/assistant turns on OpenAI's side.
+        """
+        _ = context_history
+        combined_input: List[Dict[str, Any]] = list(input_items or [])
+
+        has_function_outputs = any(
+            isinstance(item, dict) and item.get("type") == "function_call_output"
+            for item in combined_input
+        )
+
+        normalized_items: List[Dict[str, Any]] = []
+        function_output_items: List[Dict[str, Any]] = []
+
+        for item in combined_input:
+            if not isinstance(item, dict):
+                continue
+
+            item_type = str(item.get("type") or "").strip().lower()
+            if item_type == "function_call_output":
+                call_id = str(item.get("call_id") or "").strip()
+                if not call_id:
+                    continue
+
+                normalized_output = {
+                    "type": "function_call_output",
+                    "call_id": call_id,
+                    "output": item.get("output", ""),
+                }
+                normalized_items.append(normalized_output)
+                function_output_items.append(normalized_output)
+                continue
+
+            if item_type == "function_call":
+                normalized_items.extend(self._normalize_tool_call_items([item]))
+                continue
+
+            role = str(item.get("role") or "").strip().lower()
+            if role == "model":
+                role = "assistant"
+
+            content = item.get("content")
+            tool_calls = self._normalize_tool_call_items(item.get("tool_calls"))
+            if tool_calls:
+                if role == "assistant" and content not in (None, "", []):
+                    normalized_items.append({
+                        "role": role,
+                        "content": content,
+                    })
+                normalized_items.extend(tool_calls)
+                continue
+
+            if role:
+                normalized_items.append({
+                    "role": role,
+                    "content": content,
+                })
+
+        if previous_response_id and has_function_outputs and function_output_items:
+            return function_output_items
+
+        return normalized_items
+
+    @staticmethod
+    def _normalize_tool_call_items(tool_calls: Any) -> List[Dict[str, Any]]:
+        normalized_tool_calls: List[Dict[str, Any]] = []
+        if not isinstance(tool_calls, list):
+            return normalized_tool_calls
+
+        for tool_call in tool_calls:
+            if isinstance(tool_call, dict):
+                function = tool_call.get("function") or {}
+                call_id = str(
+                    tool_call.get("call_id")
+                    or tool_call.get("id")
+                    or ""
+                ).strip()
+                name = str(function.get("name") or tool_call.get("name") or "").strip()
+                arguments = str(function.get("arguments") or tool_call.get("arguments") or "{}")
+            else:
+                function = getattr(tool_call, "function", None)
+                call_id = str(
+                    getattr(tool_call, "call_id", None)
+                    or getattr(tool_call, "id", None)
+                    or ""
+                ).strip()
+                name = str(
+                    getattr(function, "name", None)
+                    or getattr(tool_call, "name", None)
+                    or ""
+                ).strip()
+                arguments = str(
+                    getattr(function, "arguments", None)
+                    or getattr(tool_call, "arguments", None)
+                    or "{}"
+                )
+
+            if not call_id or not name:
+                continue
+
+            normalized_tool_calls.append({
+                "type": "function_call",
+                "call_id": call_id,
+                "name": name,
+                "arguments": arguments,
+            })
+
+        return normalized_tool_calls
+
     @staticmethod
     def _record_telemetry_input(telemetry_execution: Any, payload: Dict[str, Any]) -> None:
         record_input = getattr(telemetry_execution, "record_input", None)

{iatoolkit-2.6.3 → iatoolkit-2.6.4}/src/iatoolkit/locales/en.yaml

@@ -29,6 +29,10 @@ ui:
 
   mon:
     system_status: "System Status"
+    worker_service: "Worker"
+    memory_short: "Mem"
+    cpu_short: "CPU"
+    worker_metrics_unavailable: "Worker service metrics unavailable"
     latency_p95: "Latency (Avg)"
     error_rate: "Error Rate (1h)"
     queue: "Pending Tasks"
@@ -341,6 +345,7 @@ ui:
     last_ingestion: "Last ingestion"
     rag: "RAG"
     detail: "Detail"
+    infrastructure: "Infrastructure"
     toolkit: "Toolkit"
     tasks: "Tasks"
     waiting: "waiting"

{iatoolkit-2.6.3 → iatoolkit-2.6.4}/src/iatoolkit/locales/es.yaml

@@ -30,6 +30,10 @@ ui:
 
   mon:
     system_status: "Estado Sistema"
+    worker_service: "Worker"
+    memory_short: "Mem"
+    cpu_short: "CPU"
+    worker_metrics_unavailable: "Métricas del worker no disponibles"
     latency_p95: "Latencia (Prom)"
     error_rate: "Tasa Error (1h)"
     queue: "Tareas Pendientes"
@@ -341,6 +345,7 @@ ui:
     last_ingestion: "Última ingestión"
     rag: "RAG"
     detail: "Detalle"
+    infrastructure: "Infraestructura"
     toolkit: "Toolkit"
     tasks: "Tareas"
     waiting: "esperando"

iatoolkit-2.6.4/src/iatoolkit/views/invocations_api_view.py

@@ -0,0 +1,75 @@
+from flask import jsonify, request
+from flask.views import MethodView
+from injector import inject
+
+from iatoolkit.services.auth_service import AuthService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.services.query_service import QueryService
+import logging
+
+
+class InvocationsApiView(MethodView):
+    """
+    Stateless API endpoint for externally invoking agents/prompts or direct questions.
+    Authenticates via API Key or web session and always skips chat history.
+    """
+
+    @inject
+    def __init__(
+        self,
+        auth_service: AuthService,
+        query_service: QueryService,
+        i18n_service: I18nService,
+    ):
+        self.auth_service = auth_service
+        self.query_service = query_service
+        self.i18n_service = i18n_service
+
+    def post(self, company_short_name: str):
+        try:
+            auth_result = self.auth_service.verify_for_company(company_short_name)
+            if not auth_result.get("success"):
+                return jsonify(auth_result), auth_result.get("status_code")
+
+            user_identifier = auth_result.get("user_identifier")
+
+            data = request.get_json()
+            if not data:
+                return jsonify({"error": "Invalid JSON body"}), 400
+
+            prompt_name = data.get("agent_name") or data.get("prompt_name")
+
+            result = self.query_service.llm_query(
+                company_short_name=company_short_name,
+                user_identifier=user_identifier,
+                model=data.get("model", ""),
+                llm_request_options={
+                    "reasoning_effort": data.get("reasoning_effort", ""),
+                },
+                question=data.get("question", ""),
+                prompt_name=prompt_name,
+                client_data=data.get("client_data", {}),
+                ignore_history=True,
+                files=data.get("files", []),
+            )
+            if "error" in result:
+                return jsonify(result), 409
+
+            # keep API response compact: expose structured_output but hide schema diagnostics
+            result.pop("schema_valid", None)
+            result.pop("schema_errors", None)
+            result.pop("schema_mode", None)
+            result.pop("schema_applied", None)
+
+            return jsonify(result), 200
+
+        except Exception as e:
+            logging.exception("Unexpected error in invocations API: %s", e)
+            return jsonify(
+                {
+                    "error": True,
+                    "error_message": self.i18n_service.t(
+                        "errors.general.unexpected_error"
+                    ),
+                }
+            ), 500

{iatoolkit-2.6.3 → iatoolkit-2.6.4/src/iatoolkit.egg-info}/PKG-INFO

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

{iatoolkit-2.6.3 → iatoolkit-2.6.4}/src/iatoolkit.egg-info/SOURCES.txt

@@ -212,6 +212,7 @@ src/iatoolkit/views/help_content_api_view.py
 src/iatoolkit/views/history_api_view.py
 src/iatoolkit/views/home_view.py
 src/iatoolkit/views/init_context_api_view.py
+src/iatoolkit/views/invocations_api_view.py
 src/iatoolkit/views/llmquery_api_view.py
 src/iatoolkit/views/load_document_api_view.py
 src/iatoolkit/views/login_view.py