lollms-client 1.3.3__py3-none-any.whl → 1.3.6__py3-none-any.whl

lollms_client/llm_bindings/lollms/__init__.py

@@ -67,178 +67,177 @@ class LollmsBinding(LollmsLLMBinding):
         else:
             return {"status": False, "error": response.text}
 
-    
-    def generate_text(self,
-                     prompt: str,
-                     images: Optional[List[str]] = None,
-                     system_prompt: str = "",
-                     n_predict: Optional[int] = None,
-                     stream: Optional[bool] = None,
-                     temperature: float = 0.7, 
-                     top_k: int = 40,          
-                     top_p: float = 0.9,       
-                     repeat_penalty: float = 1.1, 
-                     repeat_last_n: int = 64, 
-                     seed: Optional[int] = None,
-                     n_threads: Optional[int] = None,
-                     ctx_size: int | None = None,
-                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
-                     split:Optional[bool]=False, # put to true if the prompt is a discussion
-                     user_keyword:Optional[str]="!@>user:",
-                     ai_keyword:Optional[str]="!@>assistant:",
-                     ) -> Union[str, dict]:
-        """
-        Generate text using the active LLM binding, using instance defaults if parameters are not provided.
+  
+    def _build_openai_params(self, messages: list, **kwargs) -> dict:
+        model = kwargs.get("model", self.model_name)
+        if "n_predict" in kwargs:
+            kwargs["max_tokens"] = kwargs.pop("n_predict")
+
+        restricted_families = [
+            "gpt-5",
+            "gpt-4o",
+            "o1",
+            "o3",
+            "o4"
+        ]
 
-        Args:
-            prompt (str): The input prompt for text generation.
-            images (Optional[List[str]]): List of image file paths for multimodal generation.
-            n_predict (Optional[int]): Maximum number of tokens to generate. Uses instance default if None.
-            stream (Optional[bool]): Whether to stream the output. Uses instance default if None.
-            temperature (Optional[float]): Sampling temperature. Uses instance default if None.
-            top_k (Optional[int]): Top-k sampling parameter. Uses instance default if None.
-            top_p (Optional[float]): Top-p sampling parameter. Uses instance default if None.
-            repeat_penalty (Optional[float]): Penalty for repeated tokens. Uses instance default if None.
-            repeat_last_n (Optional[int]): Number of previous tokens to consider for repeat penalty. Uses instance default if None.
-            seed (Optional[int]): Random seed for generation. Uses instance default if None.
-            n_threads (Optional[int]): Number of threads to use. Uses instance default if None.
-            ctx_size (int | None): Context size override for this generation.
-            streaming_callback (Optional[Callable[[str, str], None]]): Callback function for streaming output.
-                - First parameter (str): The chunk of text received.
-                - Second parameter (str): The message type (e.g., MSG_TYPE.MSG_TYPE_CHUNK).
-            split:Optional[bool]: put to true if the prompt is a discussion
-            user_keyword:Optional[str]: when splitting we use this to extract user prompt 
-            ai_keyword:Optional[str]": when splitting we use this to extract ai prompt
+        allowed_params = {
+            "model", "messages", "temperature", "top_p", "n",
+            "stop", "max_tokens", "presence_penalty", "frequency_penalty",
+            "logit_bias", "stream", "user", "max_completion_tokens"
+        }
+
+        params = {
+            "model": model,
+            "messages": messages,
+        }
+
+        for k, v in kwargs.items():
+            if k in allowed_params and v is not None:
+                params[k] = v
+            else:
+                if v is not None:
+                    ASCIIColors.warning(f"Removed unsupported OpenAI param '{k}'")
+
+        model_lower = model.lower()
+        if any(fam in model_lower for fam in restricted_families):
+            if "temperature" in params and params["temperature"] != 1:
+                ASCIIColors.warning(f"{model} does not support temperature != 1. Overriding to 1.")
+                params["temperature"] = 1
+            if "top_p" in params:
+                ASCIIColors.warning(f"{model} does not support top_p. Removing it.")
+                params.pop("top_p")
+
+        return params
+  
+    def generate_text(self,
+                    prompt: str,
+                    images: Optional[List[str]] = None,
+                    system_prompt: str = "",
+                    n_predict: Optional[int] = None,
+                    stream: Optional[bool] = None,
+                    temperature: float = 0.7, 
+                    top_k: int = 40,          
+                    top_p: float = 0.9,       
+                    repeat_penalty: float = 1.1, 
+                    repeat_last_n: int = 64, 
+                    seed: Optional[int] = None,
+                    n_threads: Optional[int] = None,
+                    ctx_size: int | None = None,
+                    streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                    split: Optional[bool] = False,
+                    user_keyword: Optional[str] = "!@>user:",
+                    ai_keyword: Optional[str] = "!@>assistant:"
+                    ) -> Union[str, dict]:
 
-        Returns:
-            Union[str, dict]: Generated text or error dictionary if failed.
-        """
         count = 0
         output = ""
-        messages = [
-            {
-                "role": "system",
-                "content": system_prompt or "You are a helpful assistant.",
-            }
-        ]
+        messages = [{"role": "system", "content": system_prompt or "You are a helpful assistant."}]
 
-        # Prepare messages based on whether images are provided
         if images:
             if split:
-                messages += self.split_discussion(prompt,user_keyword=user_keyword, ai_keyword=ai_keyword)
-                if images:
-                    messages[-1]["content"] = [
-                        {
-                            "type": "text",
-                            "text": messages[-1]["content"]
-                        }
-                    ]+[
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:image/jpeg;base64,{encode_image(image_path)}"
-                            }
-                        }
-                        for image_path in images
-                    ]
+                messages += self.split_discussion(prompt, user_keyword=user_keyword, ai_keyword=ai_keyword)
+                messages[-1]["content"] = [{"type": "text", "text": messages[-1]["content"]}] + [
+                    {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{encode_image(path)}"}}
+                    for path in images
+                ]
             else:
                 messages.append({
-                        'role': 'user', 
-                        'content': [
-                                        {
-                                            "type": "text",
-                                            "text": prompt
-                                        }
-                                    ] + [
-                                        {
-                                            "type": "image_url",
-                                            "image_url": {
-                                                "url": f"data:image/jpeg;base64,{encode_image(image_path)}"
-                                            }
-                                        }
-                                        for image_path in images
-                                    ]
-                    }
-                )
-            
+                    'role': 'user',
+                    'content': [{"type": "text", "text": prompt}] + [
+                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{encode_image(path)}"}}
+                        for path in images
+                    ]
+                })
         else:
-            
             if split:
-                messages += self.split_discussion(prompt,user_keyword=user_keyword, ai_keyword=ai_keyword)
-                if images:
-                    messages[-1]["content"] = [
-                        {
-                            "type": "text",
-                            "text": messages[-1]["content"]
-                        }
-                    ]
+                messages += self.split_discussion(prompt, user_keyword=user_keyword, ai_keyword=ai_keyword)
             else:
-                messages.append({
-                        'role': 'user', 
-                        'content': [
-                                        {
-                                            "type": "text",
-                                            "text": prompt
-                                        }
-                                    ]
-                    }
-                )
-
-        # Generate text using the OpenAI API
-        if self.completion_format == ELF_COMPLETION_FORMAT.Chat:
-            chat_completion = self.client.chat.completions.create(
-                model=self.model_name,  # Choose the engine according to your OpenAI plan
-                messages=messages,
-                max_tokens=n_predict,  # Adjust the desired length of the generated response
-                n=1,  # Specify the number of responses you want
-                temperature=temperature,  # Adjust the temperature for more or less randomness in the output
-                stream=stream
-            )
+                messages.append({'role': 'user', 'content': [{"type": "text", "text": prompt}]})
 
-            if stream:
-                for resp in chat_completion:
-                    if count >= n_predict:
-                        break
-                    try:
-                        word = resp.choices[0].delta.content
-                    except Exception as ex:
-                        word = ""
-                    if streaming_callback is not None:
-                        if not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
+        try:
+            if self.completion_format == ELF_COMPLETION_FORMAT.Chat:
+                params = self._build_openai_params(messages=messages,
+                                                n_predict=n_predict,
+                                                stream=stream,
+                                                temperature=temperature,
+                                                top_p=top_p,
+                                                repeat_penalty=repeat_penalty,
+                                                seed=seed)
+                try:
+                    chat_completion = self.client.chat.completions.create(**params)
+                except Exception as ex:
+                    # exception for new openai models
+                    params["max_completion_tokens"]=params["max_tokens"]
+                    params["temperature"]=1
+                    try: del params["max_tokens"] 
+                    except Exception: pass
+                    try: del params["top_p"]
+                    except Exception: pass
+                    try: del params["frequency_penalty"]
+                    except Exception: pass
+                    
+                    chat_completion = self.client.chat.completions.create(**params)                
+
+                if stream:
+                    for resp in chat_completion:
+                        if count >= (n_predict or float('inf')):
                             break
-                    if word:
-                        output += word
-                        count += 1
+                        word = getattr(resp.choices[0].delta, "content", "") or ""
+                        if streaming_callback and not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
+                            break
+                        if word:
+                            output += word
+                            count += 1
+                else:
+                    output = chat_completion.choices[0].message.content
+
             else:
-                output = chat_completion.choices[0].message.content
-        else:
-            completion = self.client.completions.create(
-                model=self.model_name,  # Choose the engine according to your OpenAI plan
-                prompt=prompt,
-                max_tokens=n_predict,  # Adjust the desired length of the generated response
-                n=1,  # Specify the number of responses you want
-                temperature=temperature,  # Adjust the temperature for more or less randomness in the output
-                stream=stream
-            )
+                params = self._build_openai_params(prompt=prompt,
+                                                n_predict=n_predict,
+                                                stream=stream,
+                                                temperature=temperature,
+                                                top_p=top_p,
+                                                repeat_penalty=repeat_penalty,
+                                                seed=seed)
+                try:
+                    completion =  self.client.completions.create(**params)
+                except Exception as ex:
+                    # exception for new openai models
+                    params["max_completion_tokens"]=params["max_tokens"]
+                    params["temperature"]=1
+                    try: del params["max_tokens"] 
+                    except Exception: pass
+                    try: del params["top_p"]
+                    except Exception: pass
+                    try: del params["frequency_penalty"]
+                    except Exception: pass
 
-            if stream:
-                for resp in completion:
-                    if count >= n_predict:
-                        break
-                    try:
-                        word = resp.choices[0].text
-                    except Exception as ex:
-                        word = ""
-                    if streaming_callback is not None:
-                        if not streaming_callback(word, "MSG_TYPE_CHUNK"):
+                    
+                    completion =  self.client.completions.create(**params)                
+
+                if stream:
+                    for resp in completion:
+                        if count >= (n_predict or float('inf')):
                             break
-                    if word:
-                        output += word
-                        count += 1
-            else:
-                output = completion.choices[0].text
+                        word = getattr(resp.choices[0], "text", "") or ""
+                        if streaming_callback and not streaming_callback(word, MSG_TYPE.MSG_TYPE_CHUNK):
+                            break
+                        if word:
+                            output += word
+                            count += 1
+                else:
+                    output = completion.choices[0].text
+
+        except Exception as e:
+            trace_exception(e)
+            err_msg = f"An error occurred with the OpenAI API: {e}"
+            if streaming_callback:
+                streaming_callback(err_msg, MSG_TYPE.MSG_TYPE_EXCEPTION)
+            return {"status": "error", "message": err_msg}
 
         return output
+
     
     def generate_from_messages(self,
                      messages: List[Dict],

lollms_client/lollms_core.py

@@ -1483,7 +1483,7 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
             system_prompt: str|None = None,
             reasoning_system_prompt: str = "You are a logical AI assistant. Your task is to achieve the user's goal by thinking step-by-step and using the available tools.",
             images: Optional[List[str]] = None,
-            max_reasoning_steps: int = 15,
+            max_reasoning_steps: int|None = None,
             decision_temperature: float = 0.5,
             final_answer_temperature: float = 0.7,
             streaming_callback: Optional[Callable[[str, 'MSG_TYPE', Optional[Dict], Optional[List]], bool]] = None,
@@ -1499,6 +1499,14 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
         
         if not self.llm:
             return {"final_answer": "", "tool_calls": [], "sources": [], "error": "LLM binding not initialized."}
+        if max_reasoning_steps is None:
+            max_reasoning_steps=15
+        if rag_min_similarity_percent is None:
+            rag_min_similarity_percent=50.0
+        if final_answer_temperature is None:
+            final_answer_temperature=0.7
+        if rag_top_k is None:
+            rag_top_k=5
 
         def log_event(desc, event_type=MSG_TYPE.MSG_TYPE_CHUNK, meta=None, event_id=None) -> Optional[str]:
             if not streaming_callback: return None
@@ -1606,7 +1614,7 @@ Output ONLY the JSON for the tool's parameters: {{"tool_params": {{...}}}}"""
                 else:
                     tool_result = {"status": "failure", "error": f"Tool '{tool_name}' could not be executed in single-step mode."}
                 
-                if tool_result.get("status") != "success":
+                if tool_result.get("status","success") != "success" or "error" in tool_result:
                     error_detail = tool_result.get("error", "Unknown tool error in single-step mode.")
                     raise RuntimeError(error_detail)
 
@@ -1734,7 +1742,7 @@ Output only: {{"tool_params": {{...}}}}"""
                     if tool_name in rag_registry:
                         query = hydrated_params.get("query", "")
                         top_k, min_sim = rag_tool_specs[tool_name]["default_top_k"], rag_tool_specs[tool_name]["default_min_sim"]
-                        raw_results = rag_registry[tool_name](query=query, top_k=top_k)
+                        raw_results = rag_registry[tool_name](query=query, rag_top_k=top_k)
                         raw_iter = raw_results["results"] if isinstance(raw_results, dict) and "results" in raw_results else raw_results
                         docs = [{"text": d.get("text", str(d)), "score": d.get("score", 0)*100, "metadata": d.get("metadata", {})} for d in raw_iter or []]
                         kept = [x for x in docs if x['score'] >= min_sim]
@@ -1832,7 +1840,7 @@ FINAL ANSWER:"""
         if not  system_prompt:
             system_prompt = f"""Act as a code generation assistant that generates code from user prompt."""
 
-        if template:
+        if template and template !="{}":
             if language in ["json","yaml","xml"]:
                 system_prompt += f"\nMake sure the generated context follows the following schema:\n```{language}\n{template}\n```\n"
             else:
@@ -1921,92 +1929,172 @@ Do not split the code in multiple tags.
     def generate_structured_content(
         self,
         prompt,
-        images=[],
-        schema={},
+        images=None,
+        schema=None,
         system_prompt=None,
+        max_retries=1,
         **kwargs
     ):
-        """
-        Generates structured data (a dict) from a prompt using a JSON schema.
-
-        This method is a high-level wrapper around `generate_code`, specializing it 
-        for JSON output. It ensures the LLM sticks to a predefined structure,
-        and then parses the output into a Python dictionary.
-
-        Args:
-            prompt (str): 
-                The user's request (e.g., "Extract the name, age, and city of the person described").
-            schema (dict or str): 
-                A Python dictionary or a JSON string representing the desired output 
-                structure. This will be used as a schema for the LLM.
-                Example: {"name": "string", "age": "integer", "city": "string"}
-            system_prompt (str, optional): 
-                Additional instructions for the system prompt, to be appended to the 
-                main instructions. Defaults to None.
-            **kwargs: 
-                Additional keyword arguments to be passed directly to the 
-                `generate_code` method (e.g., temperature, n_predict, top_k, debug).
+        import json
+        images = [] if images is None else images
+        schema = {} if schema is None else schema
+        try:
+            from jsonschema import validate
+            has_validator = True
+        except ImportError:
+            has_validator = False
 
-        Returns:
-            dict: The parsed JSON data as a Python dictionary, or None if
-                generation or parsing fails.
-        """
-        # 1. Validate and prepare the schema string from the schema
         if isinstance(schema, dict):
-            # Convert the dictionary to a nicely formatted JSON string for the schema
-            schema_str = json.dumps(schema, indent=2)
+            schema_obj = schema
         elif isinstance(schema, str):
-            # Assume it's already a valid JSON string schema
-            schema_str = schema
+            try:
+                schema_obj = json.loads(schema)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"The provided schema string is not valid JSON: {e}")
         else:
-            # It's good practice to fail early for invalid input types
             raise TypeError("schema must be a dict or a JSON string.")
-        # 2. Construct a specialized system prompt for structured data generation
-        full_system_prompt = (
-            "Your objective is to build a json structured output based on the user's request and the provided schema."
-            "Your entire response must be a single valid JSON object within a markdown code block."
-            "do not use tabs in your response."
+
+        # --- FIX STARTS HERE ---
+        # Heuristic to detect if the schema is a properties-only dictionary
+        # and needs to be wrapped in a root object to be a valid schema.
+        # This handles cases where the user provides `{"field1": {...}, "field2": {...}}`
+        # instead of `{"type": "object", "properties": {"field1": ...}}`.
+        if "type" not in schema_obj and "properties" not in schema_obj and all(isinstance(v, dict) for v in schema_obj.values()):
+            if kwargs.get("debug"):
+                ASCIIColors.info("Schema appears to be a properties-only dictionary; wrapping it in a root object.")
+            schema_obj = {
+                "type": "object",
+                "properties": schema_obj,
+                # Assume all top-level keys are required when wrapping
+                "required": list(schema_obj.keys())
+            }
+        # --- FIX ENDS HERE ---
+
+        def _instance_skeleton(s):
+            if not isinstance(s, dict):
+                return {}
+            if "const" in s:
+                return s["const"]
+            if "enum" in s and isinstance(s["enum"], list) and s["enum"]:
+                return s["enum"][0]
+            
+            # Handle default values
+            if "default" in s:
+                return s["default"]
+
+            t = s.get("type")
+            if t == "string":
+                return ""
+            if t == "integer":
+                return 0
+            if t == "number":
+                return 0.0
+            if t == "boolean":
+                return False
+            if t == "array":
+                # Generate one minimal item if schema is provided
+                items = s.get("items", {})
+                min_items = s.get("minItems", 0)
+                # Let's generate at least one item for the example if possible
+                num_items = max(min_items, 1) if items and not min_items == 0 else min_items
+                return [_instance_skeleton(items) for _ in range(num_items)]
+            if t == "object":
+                props = s.get("properties", {})
+                # Use required fields, otherwise fall back to all properties for the skeleton
+                req = s.get("required", list(props.keys()))
+                out = {}
+                for k in req:
+                    if k in props:
+                        out[k] = _instance_skeleton(props[k])
+                    else:
+                        out[k] = None # Should not happen if schema is well-formed
+                return out
+            if "oneOf" in s and isinstance(s["oneOf"], list) and s["oneOf"]:
+                return _instance_skeleton(s["oneOf"][0])
+            if "anyOf" in s and isinstance(s["anyOf"], list) and s["anyOf"]:
+                return _instance_skeleton(s["anyOf"][0])
+            if "allOf" in s and isinstance(s["allOf"], list) and s["allOf"]:
+                merged = {}
+                for sub in s["allOf"]:
+                    val = _instance_skeleton(sub)
+                    if isinstance(val, dict):
+                        merged.update(val)
+                return merged if merged else {}
+            return {}
+
+        # Now derive strings from the (potentially corrected) schema_obj
+        schema_str = json.dumps(schema_obj, indent=2, ensure_ascii=False)
+        example_obj = _instance_skeleton(schema_obj)
+        example_str = json.dumps(example_obj, indent=2, ensure_ascii=False)
+
+        base_system = (
+            "Your objective is to generate a JSON object that satisfies the user's request and conforms to the provided schema.\n"
+            "Rules:\n"
+            "1) The schema is reference ONLY. Do not include the schema in the output.\n"
+            "2) Output exactly ONE valid JSON object.\n"
+            "3) Wrap the JSON object inside a single ```json code block.\n"
+            "4) Do not output explanations or text outside the JSON.\n"
+            "5) Use 2 spaces for indentation. Do not use tabs.\n"
+            "6) Only include fields allowed by the schema and ensure all required fields are present.\n"
+            "7) For enums, choose a valid value from the list.\n\n"
+            "Schema (reference only):\n"
+            f"```json\n{schema_str}\n```\n\n"
+            "Correct example of output format (structure only, values are illustrative):\n"
+            f"```json\n{example_str}\n```"
         )
-        if system_prompt:
-            full_system_prompt = f"{system_prompt}\n\n{full_system_prompt}"
+        full_system_prompt = f"{system_prompt}\n\n{base_system}" if system_prompt else base_system
 
-        # 3. Call the underlying generate_code method with JSON-specific settings
-        if kwargs.get('debug'):
+        if kwargs.get("debug"):
             ASCIIColors.info("Generating structured content...")
 
-        json_string = self.generate_code(
-            prompt=prompt,
-            images=images,
-            system_prompt=full_system_prompt,
-            template=schema_str,
-            language="json",
-            code_tag_format="markdown", # Sticking to markdown is generally more reliable
-            **kwargs # Pass other params like temperature, top_k, etc.
-        )
-
-        # 4. Parse the result and return
-        if not json_string:
-            # generate_code already logs the error, so no need for another message
-            return None
+        last_error = None
+        for attempt in range(max_retries + 1):
+            json_string = self.generate_code(
+                prompt=prompt,
+                images=images,
+                system_prompt=full_system_prompt if attempt == 0 else f"{full_system_prompt}\n\nPrevious attempt failed validation: {last_error}\nReturn a corrected JSON instance that strictly satisfies the schema.",
+                template=example_str,
+                language="json",
+                code_tag_format="markdown",
+                **kwargs
+            )
+            if not json_string:
+                last_error = "LLM returned an empty response."
+                if kwargs.get("debug"): ASCIIColors.warning(last_error)
+                continue
 
-        if kwargs.get('debug'):
-            ASCIIColors.info("Parsing generated JSON string...")
-            print(f"--- Raw JSON String ---\n{json_string}\n-----------------------")
+            if kwargs.get("debug"):
+                ASCIIColors.info("Parsing generated JSON string...")
+                print(f"--- Raw JSON String ---\n{json_string}\n-----------------------")
 
-        try:
-            # Use the provided robust parser
-            parsed_json = robust_json_parser(json_string)
-            
-            if parsed_json is None:
-                ASCIIColors.warning("Failed to robustly parse the generated JSON.")
-                return None
+            try:
+                parsed_json = robust_json_parser(json_string)
+                if parsed_json is None:
+                    last_error = "Failed to robustly parse the generated string into JSON."
+                    if kwargs.get("debug"): ASCIIColors.warning(last_error)
+                    continue
                 
-            return parsed_json
-
-        except Exception as e:
-            trace_exception(e)
-            ASCIIColors.error(f"An unexpected error occurred during JSON parsing: {e}")
-            return None
+                if has_validator:
+                    try:
+                        validate(instance=parsed_json, schema=schema_obj)
+                        return parsed_json
+                    except Exception as ve:
+                        last_error = f"JSON Schema Validation Error: {ve}"
+                        if kwargs.get("debug"): ASCIIColors.warning(last_error)
+                        if attempt < max_retries:
+                            continue
+                        # Return the invalid object after last retry if validation fails
+                        return parsed_json
+                return parsed_json
+            except Exception as e:
+                trace_exception(e)
+                ASCIIColors.error(f"Unexpected error during JSON processing: {e}")
+                last_error = f"An unexpected error occurred: {e}"
+                # Do not retry on unexpected errors, break the loop
+                break
+        
+        ASCIIColors.error(f"Failed to generate valid structured content after {max_retries + 1} attempts. Last error: {last_error}")
+        return None
 
 
     def extract_code_blocks(self, text: str, format: str = "markdown") -> List[dict]:

lollms_client/lollms_discussion.py

@@ -1944,7 +1944,7 @@ class LollmsDiscussion:
                 "required": ["title"],
                 "description": "JSON object as title of the discussion."
             }
-            infos = self.lollmsClient.generate_structured_content(prompt = prompt, system_prompt=system_prompt, schema = title_generation_schema)
+            infos = self.lollmsClient.generate_structured_content(prompt = prompt, system_prompt=system_prompt, schema = title_generation_schema, n_predict=512)
             if infos is None or "title" not in infos:
                 raise ValueError("Title generation failed or returned invalid data.")
             discussion_title = infos["title"]
@@ -1995,7 +1995,7 @@ class LollmsDiscussion:
           (a list of base64 strings), it converts it to the new format (a list
           of dictionaries) and marks the discussion for saving.
         """
-        if not self.images:
+        if not self.images or len(self.images) == 0 or type(self.images) is not list:
             return []
 
         # Check if migration is needed (if the first element is a string).