iatoolkit 0.71.4__py3-none-any.whl → 1.4.2__py3-none-any.whl

iatoolkit/infra/llm_providers/deepseek_adapter.py

@@ -0,0 +1,278 @@
+# deepseek_adapter.py
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import logging
+from typing import Dict, List, Optional, Any
+
+from iatoolkit.infra.llm_response import LLMResponse, ToolCall, Usage
+from iatoolkit.common.exceptions import IAToolkitException
+import json
+
+class DeepseekAdapter:
+    """
+    Adapter for DeepSeek using the OpenAI-compatible Chat Completions API.
+    It translates IAToolkit's common request/response format into
+    DeepSeek chat.completions calls.
+    """
+
+    def __init__(self, deepseek_client):
+        # deepseek_client is an OpenAI client configured with base_url="https://api.deepseek.com"
+        self.client = deepseek_client
+
+    # ------------------------------------------------------------------
+    # Public entry point
+    # ------------------------------------------------------------------
+
+    def create_response(self, model: str, input: List[Dict], **kwargs) -> LLMResponse:
+        """
+        Entry point called by LLMProxy.
+
+        :param model: DeepSeek model name (e.g. "deepseek-chat").
+        :param input: Common IAToolkit input list. It may contain:
+                      - normal messages: {"role": "...", "content": "..."}
+                      - function outputs: {"type": "function_call_output",
+                                           "call_id": "...", "output": "..."}
+        :param kwargs: extra options (tools, tool_choice, context_history, etc.).
+        """
+        tools = kwargs.get("tools") or []
+        tool_choice = kwargs.get("tool_choice", "auto")
+        context_history = kwargs.get("context_history") or []
+
+        try:
+            # 1) Build messages from history (if any)
+            messages: List[Dict[str, Any]] = []
+            if context_history:
+                history_messages = self._build_messages_from_input(context_history)
+                messages.extend(history_messages)
+
+            # 2) Append current turn messages
+            current_messages = self._build_messages_from_input(input)
+            messages.extend(current_messages)
+
+            # Detect if this input already contains function_call_output items.
+            # That means we are in the "second phase" after executing tools.
+            has_function_outputs = any(
+                item.get("type") == "function_call_output" for item in input
+            )
+
+            # 3) Build the tools payload
+            tools_payload = self._build_tools_payload(tools)
+
+            # If we already have function_call_output messages and the caller did not force
+            # a specific tool_choice (e.g. "required" for SQL retry), we disable tools and
+            # tool_choice to avoid infinite tool-calling loops (especially with iat_sql_query).
+            if has_function_outputs and tool_choice == "auto":
+                logging.debug(
+                    "[DeepseekAdapter] Detected function_call_output in input; "
+                    "disabling tools and tool_choice to avoid tool loop."
+                )
+                tools_payload = None
+                tool_choice = None
+
+            logging.debug(f"[DeepseekAdapter] messages={messages}")
+            logging.debug(f"[DeepseekAdapter] tools={tools_payload}, tool_choice={tool_choice}")
+
+            # Build kwargs for API call, skipping empty parameters
+            call_kwargs: Dict[str, Any] = {
+                "model": model,
+                "messages": messages,
+            }
+            if tools_payload:
+                call_kwargs["tools"] = tools_payload
+            if tool_choice:
+                call_kwargs["tool_choice"] = tool_choice
+
+            logging.debug(f"[DeepseekAdapter] Calling DeepSeek chat.completions API...: {json.dumps(messages, indent=2)}")
+            response = self.client.chat.completions.create(**call_kwargs)
+
+            return self._map_deepseek_chat_response(response)
+
+        except IAToolkitException:
+            # Re-raise IAToolkit exceptions as is
+            raise
+        except Exception as ex:
+            logging.exception("Unexpected error calling DeepSeek")
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.LLM_ERROR,
+                f"DeepSeek error: {ex}"
+            ) from ex
+
+    # ------------------------------------------------------------------
+    # Helpers to build the request
+    # ------------------------------------------------------------------
+
+    def _build_messages_from_input(self, input_items: List[Dict]) -> List[Dict]:
+        """
+        Transform IAToolkit 'input' items into ChatCompletion 'messages'.
+
+        We handle:
+        - Standard messages with 'role' and 'content'.
+        - function_call_output items by converting them into assistant messages
+          containing the tool result, so the model can use them to answer.
+        """
+        messages: List[Dict[str, Any]] = []
+
+        for item in input_items:
+            # Tool call outputs are mapped to assistant messages with the tool result.
+            if item.get("type") == "function_call_output":
+                output = item.get("output", "")
+                if not output:
+                    logging.warning(
+                        "[DeepseekAdapter] function_call_output item without 'output': %s",
+                        item
+                    )
+                    continue
+
+                messages.append(
+                    {
+                        "role": "user",
+                        "content": f"Tool result:\n{output}",
+                    }
+                )
+                continue
+
+            role = item.get("role")
+            content = item.get("content")
+
+            # Skip tool-role messages completely for DeepSeek
+            if role == "tool":
+                logging.warning(f"[DeepseekAdapter] Skipping tool-role message: {item}")
+                continue
+
+            if not role:
+                logging.warning(f"[DeepseekAdapter] Skipping message without role: {item}")
+                continue
+
+            messages.append({"role": role, "content": content})
+
+        return messages
+
+    def _build_tools_payload(self, tools: List[Dict]) -> Optional[List[Dict]]:
+        """
+        Transform IAToolkit tool definitions into DeepSeek/OpenAI chat tools format.
+
+        Expected internal tool format:
+        {
+            "type": "function",
+            "name": ...,
+            "description": ...,
+            "parameters": {...},
+            "strict": True/False
+        }
+        Or already in OpenAI tools format with "function" key.
+        """
+        if not tools:
+            return None
+
+        tools_payload: List[Dict[str, Any]] = []
+
+        for tool in tools:
+            # If it's already in OpenAI 'function' format, reuse it
+            if "function" in tool:
+                func_def = tool["function"]
+            else:
+                # Build function definition from flattened structure
+                func_def = {
+                    "name": tool.get("name"),
+                    "description": tool.get("description", ""),
+                    "parameters": tool.get("parameters", {}) or {},
+                }
+
+            # Ensure parameters is a dict
+            if "parameters" in func_def and not isinstance(func_def["parameters"], dict):
+                logging.warning(
+                    "Tool parameters must be a dict; got %s",
+                    type(func_def["parameters"])
+                )
+                func_def["parameters"] = {}
+
+            ds_tool: Dict[str, Any] = {
+                "type": tool.get("type", "function"),
+                "function": func_def,
+            }
+
+            if tool.get("strict") is True:
+                ds_tool["strict"] = True
+
+            tools_payload.append(ds_tool)
+
+        return tools_payload or None
+
+    # ------------------------------------------------------------------
+    # Mapping DeepSeek response -> LLMResponse
+    # ------------------------------------------------------------------
+
+    def _map_deepseek_chat_response(self, response: Any) -> LLMResponse:
+        """
+        Map DeepSeek Chat Completion response to our common LLMResponse.
+        Handles both plain assistant messages and tool_calls.
+        """
+        # We only look at the first choice
+        if not response.choices:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.LLM_ERROR,
+                "DeepSeek response has no choices."
+            )
+
+        choice = response.choices[0]
+        message = choice.message
+
+        # Usage mapping
+        usage = Usage(
+            input_tokens=getattr(getattr(response, "usage", None), "prompt_tokens", 0) or 0,
+            output_tokens=getattr(getattr(response, "usage", None), "completion_tokens", 0) or 0,
+            total_tokens=getattr(getattr(response, "usage", None), "total_tokens", 0) or 0,
+        )
+
+        # Capture reasoning content (specific to deepseek-reasoner)
+        reasoning_content = getattr(message, "reasoning_content", "") or ""
+
+        # If the model produced tool calls, fills this list
+        tool_calls_out: List[ToolCall] = []
+
+        tool_calls = getattr(message, "tool_calls", None) or []
+        if not tool_calls:
+            # No tool calls: standard assistant message
+            output_text = getattr(message, "content", "") or ""
+            status = "completed"
+
+        else:
+            logging.debug(f"[DeepSeek] RAW tool_calls: {tool_calls}")
+
+            for tc in tool_calls:
+                func = getattr(tc, "function", None)
+                if not func:
+                    continue
+
+                name = getattr(func, "name", "")
+                arguments = getattr(func, "arguments", "") or "{}"
+
+                # DeepSeek/OpenAI return arguments as JSON string
+                logging.debug(
+                    f"[DeepSeek] ToolCall generated -> id={getattr(tc, 'id', '')} "
+                    f"name={name} arguments_raw={arguments}"
+                )
+                tool_calls_out.append(
+                    ToolCall(
+                        call_id=getattr(tc, "id", ""),
+                        type="function_call",
+                        name=name,
+                        arguments=arguments,
+                    )
+                )
+
+            status = "tool_calls"
+            output_text = ""  # caller will inspect tool_calls in .output
+
+        return LLMResponse(
+            id=getattr(response, "id", "deepseek-unknown"),
+            model=getattr(response, "model", "deepseek-unknown"),
+            status=status,
+            output_text=output_text,
+            output=tool_calls_out,
+            usage=usage,
+            reasoning_content=reasoning_content
+        )

iatoolkit/infra/{gemini_adapter.py → llm_providers/gemini_adapter.py}

@@ -13,13 +13,11 @@ import json
 import uuid
 
 class GeminiAdapter:
-    """Adaptador para la API de Gemini"""
 
     def __init__(self, gemini_client):
-        """Inicializar con cliente Gemini ya configurado"""
         self.client = gemini_client
 
-        # Configuración de seguridad - permitir contenido que podría ser bloqueado por defecto
+        # security configuration - allow content that might be blocked by default
         self.safety_settings = {
             HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
             HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
@@ -37,38 +35,36 @@ class GeminiAdapter:
                         reasoning: Optional[Dict] = None,
                         tool_choice: str = "auto",
                         ) -> LLMResponse:
-        """Llamada a la API de Gemini y mapeo a estructura común"""
         try:
-            # Inicializar el modelo de Gemini usando el cliente configurado
+            # init the model with the configured client
             gemini_model = self.client.GenerativeModel(
                 model_name=self._map_model_name(model),
                 safety_settings=self.safety_settings
             )
 
-            # Preparar el contenido para Gemini
+            # prepare the content for gemini
             if context_history:
-                # Concatenar el historial de conversación con el input actual
+                # concat the history with the current input
                 contents = self._prepare_gemini_contents(context_history + input)
             else:
-                # Usar solo el input actual si no hay historial
                 contents = self._prepare_gemini_contents(input)
 
-            # Preparar herramientas si están disponibles
+            # prepare tools
             gemini_tools = self._prepare_gemini_tools(tools) if tools else None
 
-            # Configurar generación
+            # config generation
             generation_config = self._prepare_generation_config(text, tool_choice)
 
-            # Llamar a Gemini
+            # call gemini
             if gemini_tools:
-                # Con herramientas
+                # with tools
                 response = gemini_model.generate_content(
                     contents,
                     tools=gemini_tools,
                     generation_config=generation_config
                 )
             else:
-                # Sin herramientas
+                # without tools
                 response = gemini_model.generate_content(
                     contents,
                     generation_config=generation_config
@@ -102,9 +98,7 @@ class GeminiAdapter:
 
             raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 
-    # ... rest of the methods keep the same ...
     def _map_model_name(self, model: str) -> str:
-        """Mapear nombre del modelo a formato de Gemini"""
         model_mapping = {
             "gemini-pro": "gemini-2.5-pro",
             "gemini": "gemini-2.5-pro",
@@ -115,7 +109,7 @@ class GeminiAdapter:
         return model_mapping.get(model.lower(), model)
 
     def _prepare_gemini_contents(self, input: List[Dict]) -> List[Dict]:
-        """Convertir mensajes de formato OpenAI a formato Gemini"""
+        # convert input messages to Gemini format
         gemini_contents = []
 
         for message in input:
@@ -143,7 +137,7 @@ class GeminiAdapter:
         return gemini_contents
 
     def _prepare_gemini_tools(self, tools: List[Dict]) -> List[Dict]:
-        """Convertir herramientas de formato OpenAI a formato Gemini"""
+        # convert tools to Gemini format
         if not tools:
             return None
 

iatoolkit/infra/{openai_adapter.py → llm_providers/openai_adapter.py}

@@ -7,7 +7,8 @@ import logging
 from typing import Dict, List, Optional
 from iatoolkit.infra.llm_response import LLMResponse, ToolCall, Usage
 from iatoolkit.common.exceptions import IAToolkitException
-
+import html
+from typing import List
 
 class OpenAIAdapter:
     """Adaptador para la API de OpenAI"""
@@ -53,10 +54,6 @@ class OpenAIAdapter:
             error_message = f"Error calling OpenAI API: {str(e)}"
             logging.error(error_message)
 
-            # En caso de error de contexto
-            if "context_length_exceeded" in str(e):
-                error_message = 'Tu consulta supera el limite de contexto. Reinicia el contexto con el boton de la barra superior.'
-
             raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 
     def _map_openai_response(self, openai_response) -> LLMResponse:
@@ -80,11 +77,48 @@ class OpenAIAdapter:
             total_tokens=openai_response.usage.total_tokens if openai_response.usage else 0
         )
 
+        # Reasoning content extracted from Responses output items (type="reasoning")
+        reasoning_list = self._extract_reasoning_content(openai_response)
+        reasoning_str = "\n".join(reasoning_list)
+
         return LLMResponse(
             id=openai_response.id,
             model=openai_response.model,
             status=openai_response.status,
             output_text=getattr(openai_response, 'output_text', ''),
             output=tool_calls,
-            usage=usage
-        )
+            usage=usage,
+            reasoning_content=reasoning_str
+        )
+
+    def _extract_reasoning_content(self, openai_response) -> List[str]:
+        """
+        Extract reasoning summaries (preferred) or reasoning content fragments from Responses API output.
+
+        Format required by caller:
+          1. reason is ...
+          2. reason is ...
+        """
+        reasons: List[str] = []
+
+        output_items = getattr(openai_response, "output", None) or []
+        for item in output_items:
+            if getattr(item, "type", None) != "reasoning":
+                continue
+
+            # 1) Preferred: reasoning summaries (requires reasoning={"summary":"auto"} or similar)
+            summary = getattr(item, "summary", None) or []
+            for s in summary:
+                text = getattr(s, "text", None)
+                if text:
+                    reasons.append(str(text).strip())
+
+            # 2) Fallback: some responses may carry reasoning content in "content"
+            # (e.g., content parts like {"type":"reasoning_text","text":"..."}).
+            content = getattr(item, "content", None) or []
+            for c in content:
+                text = getattr(c, "text", None)
+                if text:
+                    reasons.append(str(text).strip())
+
+        return reasons