lollms-client 0.20.2__tar.gz → 0.20.4__tar.gz

{lollms_client-0.20.2/lollms_client.egg-info → lollms_client-0.20.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.20.2
+Version: 0.20.4
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License: Apache Software License

lollms_client-0.20.4/examples/gradio_chat_app.py

@@ -0,0 +1,228 @@
+# final_working_chat_app.py
+
+import sys
+import os
+import json
+import gradio as gr
+import requests
+from typing import List, Dict, Optional, Tuple
+
+# --- Dependency Installation ---
+try:
+    import pipmaster as pm
+    print("Pipmaster found. Ensuring dependencies are installed...")
+    pm.ensure_packages(["gradio", "requests", "ascii_colors"])
+except ImportError:
+    pass
+
+# --- Import Core Components ---
+try:
+    from lollms_client import LollmsClient
+    from lollms_client.lollms_discussion import LollmsDiscussion 
+    from ascii_colors import ASCIIColors
+except ImportError as e:
+    print(f"\nFATAL: A required library is missing.\nPlease ensure lollms-client and ascii_colors are installed.")
+    print(f"Error: {e}"); sys.exit(1)
+
+# --- Standalone Helper Functions for LollmsDiscussion ---
+def export_for_chatbot(discussion: Optional[LollmsDiscussion]) -> List[Dict[str, str]]:
+    if not discussion: return []
+    branch = discussion.get_branch(discussion.active_branch_id)
+    return [{"role": discussion.participants.get(msg.sender, "user"), "content": msg.content} for msg in branch]
+
+def render_discussion_tree(discussion: Optional[LollmsDiscussion]) -> str:
+    if not discussion or not discussion.messages: return "No messages yet."
+    tree_markdown = "### Discussion Tree\n\n"; root_ids = [msg.id for msg in discussion.messages if msg.parent_id is None]
+    def _render_node(node_id: str, depth: int) -> str:
+        node = discussion.message_index.get(node_id)
+        if not node: return ""
+        is_active = "  <span class='activ'>[ACTIVE]</span>" if node.id == discussion.active_branch_id else ""
+        line = f"{'    ' * depth}- **{node.sender}**: _{node.content.replace(chr(10), ' ').strip()[:60]}..._{is_active}\n"
+        for child_id in discussion.children_index.get(node.id, []): line += _render_node(child_id, depth + 1)
+        return line
+    for root_id in root_ids: tree_markdown += _render_node(root_id, 0)
+    return tree_markdown
+
+def get_message_choices(discussion: Optional[LollmsDiscussion]) -> List[tuple]:
+    if not discussion: return []
+    return [(f"{msg.sender}: {msg.content[:40]}...", msg.id) for msg in discussion.messages]
+
+# --- Configuration & File Management ---
+CONFIG_FILE = "config.json"; DISCUSSIONS_DIR = "discussions"; os.makedirs(DISCUSSIONS_DIR, exist_ok=True)
+DEFAULT_CONFIG = {"binding_name": "ollama", "model_name": "mistral:latest", "host_address": "http://localhost:11434", "openai_api_key": "", "openai_model_name": "gpt-4o"}
+def load_config() -> Dict:
+    if os.path.exists(CONFIG_FILE):
+        try:
+            with open(CONFIG_FILE, 'r') as f: ASCIIColors.info(f"Loaded config from {CONFIG_FILE}"); return json.load(f)
+        except: ASCIIColors.warning(f"Could not load {CONFIG_FILE}, using defaults."); return DEFAULT_CONFIG
+    return DEFAULT_CONFIG
+def save_config(config: Dict):
+    with open(CONFIG_FILE, 'w') as f: json.dump(config, f, indent=2); ASCIIColors.green(f"Saved config to {CONFIG_FILE}")
+
+# --- LollmsClient & Discussion Management ---
+def create_lollms_client(config: Dict) -> Optional[LollmsClient]:
+    try:
+        if config["binding_name"] == "ollama": client = LollmsClient(binding_name="ollama", host_address=config["host_address"], model_name=config["model_name"])
+        elif config["binding_name"] == "openai":
+            if not config.get("openai_api_key"): gr.Warning("OpenAI API key missing."); return None
+            client = LollmsClient(binding_name="openai", model_name=config["openai_model_name"], service_key=config["openai_api_key"])
+        else: gr.Warning(f"Unsupported binding: {config['binding_name']}"); return None
+        ASCIIColors.green("LollmsClient created successfully."); return client
+    except Exception as e: gr.Error(f"Failed to create LollmsClient: {e}"); return None
+def get_discussions_list() -> List[str]: return sorted([f for f in os.listdir(DISCUSSIONS_DIR) if f.endswith(".yaml")])
+def load_discussion(filename: str, client: LollmsClient) -> Optional[LollmsDiscussion]:
+    if not client: ASCIIColors.warning("Cannot load discussion: client is not initialized."); return None
+    try:
+        discussion = LollmsDiscussion(client); discussion.load_from_disk(os.path.join(DISCUSSIONS_DIR, filename))
+        ASCIIColors.info(f"Loaded discussion: {filename}"); return discussion
+    except Exception as e: gr.Error(f"Failed to load discussion {filename}: {e}"); return None
+def list_ollama_models(host: str) -> List[str]:
+    try:
+        r = requests.get(f"{host}/api/tags"); r.raise_for_status(); return [m["name"] for m in r.json().get("models", [])]
+    except: gr.Warning(f"Could not fetch models from {host}."); return []
+
+# --- Gradio UI & Logic ---
+with gr.Blocks(theme=gr.themes.Soft(), css=".activ { font-weight: bold; color: #FF4B4B; }") as demo:
+    client_state = gr.State()
+    discussion_state = gr.State()
+    
+    gr.Markdown("# 🌿 Multi-Branch Discussion App")
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📝 Session & Branch Management")
+            discussion_selector = gr.Dropdown(label="Load Discussion", interactive=True)
+            new_discussion_name = gr.Textbox(label="New Discussion Name", placeholder="Enter name and press Enter...")
+            delete_discussion_button = gr.Button("Delete Current Discussion", variant="stop")
+            branch_selector = gr.Dropdown(label="Select Message to Branch From", interactive=True)
+            discussion_tree_display = gr.Markdown("No discussion loaded.")
+        with gr.Column(scale=2):
+            with gr.Accordion("⚙️ Settings & System Prompt", open=False):
+                system_prompt_input = gr.Textbox(label="System Prompt", lines=3, interactive=True)
+                with gr.Row():
+                    binding_selector = gr.Radio(["ollama", "openai"], label="AI Binding")
+                    save_settings_button = gr.Button("Save Settings & Re-initialize", variant="primary")
+                with gr.Group(visible=True) as ollama_settings_group:
+                    ollama_host_input = gr.Textbox(label="Ollama Host Address"); ollama_model_selector = gr.Dropdown(label="Ollama Model", interactive=True); refresh_ollama_button = gr.Button("Refresh Ollama Models")
+                with gr.Group(visible=False) as openai_settings_group:
+                    openai_api_key_input = gr.Textbox(label="OpenAI API Key", type="password"); openai_model_selector = gr.Dropdown(choices=["gpt-4o", "gpt-4o-mini", "gpt-4-turbo"], label="OpenAI Model", interactive=True)
+            chatbot = gr.Chatbot(label="Conversation", height=600, type="messages")
+            user_input = gr.Textbox(show_label=False, placeholder="Type your message here...", lines=3)
+            send_button = gr.Button("Send", variant="primary")
+
+    # --- Event Handler Functions ---
+    def on_load():
+        config = load_config(); client = create_lollms_client(config)
+        discussions_list = get_discussions_list(); discussion = load_discussion(discussions_list[0], client) if discussions_list else (LollmsDiscussion(client) if client else None)
+        active_discussion_file = discussions_list[0] if discussions_list else None
+        
+        history = export_for_chatbot(discussion) if discussion else [{"role": "assistant", "content": "Welcome! Configure client in Settings and create a new chat."}]
+        tree = render_discussion_tree(discussion); branch_choices = get_message_choices(discussion)
+        sys_prompt = discussion.system_prompt if discussion else ""
+        active_branch_id = discussion.active_branch_id if discussion else None
+        is_ollama = config['binding_name'] == 'ollama'; ollama_models = list_ollama_models(config['host_address']) if is_ollama and client else []
+
+        return (client, discussion, gr.update(choices=discussions_list, value=active_discussion_file), config['binding_name'], 
+                gr.update(visible=is_ollama), gr.update(visible=not is_ollama), config['host_address'], 
+                gr.update(choices=ollama_models, value=config.get('model_name')), config['openai_api_key'], 
+                config.get('openai_model_name'), sys_prompt, history, tree, gr.update(choices=branch_choices, value=active_branch_id))
+
+    def handle_save_settings(binding, host, ollama_model, openai_key, openai_model):
+        config = {"binding_name": binding, "host_address": host, "model_name": ollama_model, "openai_api_key": openai_key, "openai_model_name": openai_model}
+        save_config(config); gr.Info("Settings saved! Reloading application..."); return on_load()
+
+    def handle_new_discussion(client, name):
+        if not client: gr.Error("Client not initialized."); return (gr.skip(),) * 5
+        if not name.strip(): gr.Warning("Provide a name."); return (gr.skip(),) * 5
+        filename = f"{name.strip().replace(' ', '_')}.yaml"
+        if os.path.exists(os.path.join(DISCUSSIONS_DIR, filename)): gr.Warning(f"Discussion '{name}' already exists."); return (gr.skip(),) * 5
+        discussion = LollmsDiscussion(client); discussion.set_participants({"user": "user", "assistant": "assistant"})
+        discussion.add_message("assistant", f"This is the beginning of '{name}'."); discussion.save_to_disk(os.path.join(DISCUSSIONS_DIR, filename))
+        return discussion, gr.update(choices=get_discussions_list(), value=filename), export_for_chatbot(discussion), render_discussion_tree(discussion), gr.update(choices=get_message_choices(discussion), value=discussion.active_branch_id)
+
+    def handle_load_discussion(client, filename):
+        if not client: gr.Error("Client not initialized."); return (gr.skip(),) * 5
+        if not filename: return (gr.skip(),) * 5
+        discussion = load_discussion(filename, client)
+        if not discussion: return (gr.skip(),) * 5
+        return discussion, discussion.system_prompt or "", export_for_chatbot(discussion), render_discussion_tree(discussion), gr.update(choices=get_message_choices(discussion), value=discussion.active_branch_id)
+
+    def handle_delete_discussion(filename):
+        if not filename: gr.Warning("No discussion selected to delete."); return (gr.skip(),) * 14
+        try:
+            os.remove(os.path.join(DISCUSSIONS_DIR, filename)); ASCIIColors.red(f"Deleted discussion: {filename}"); gr.Info(f"Deleted {filename}.")
+            return on_load()
+        except Exception as e:
+            gr.Error(f"Failed to delete file: {e}"); return (gr.skip(),) * 14
+
+    def handle_chat_submit(client, discussion, user_text, history, filename):
+        if not client: gr.Error("Client not initialized."); return
+        if not discussion: gr.Error("No discussion loaded."); return
+        if not user_text.strip(): return
+        if not filename: gr.Error("No active discussion file. Cannot save."); return
+        
+        parent_id = discussion.active_branch_id
+        discussion.add_message(sender="user", content=user_text, parent_id=parent_id)
+        history.append({"role": "user", "content": user_text}); history.append({"role": "assistant", "content": ""})
+        yield history
+        
+        full_response = ""
+        try:
+            # The callback must return True to continue the stream.
+            for chunk in client.chat(discussion, stream=True, streaming_callback=lambda c,t: True):
+                full_response += chunk; history[-1]["content"] = full_response; yield history
+            discussion.add_message(sender="assistant", content=full_response); discussion.save_to_disk(os.path.join(DISCUSSIONS_DIR, filename))
+        except Exception as e:
+            full_response = f"An error occurred: {e}"; gr.Error(full_response); history[-1]["content"] = full_response
+            discussion.add_message(sender="assistant", content=f"ERROR: {full_response}")
+
+    def on_chat_finish(discussion):
+        # This function updates non-streaming components after the chat is done
+        if not discussion: return gr.skip(), gr.skip()
+        return render_discussion_tree(discussion), gr.update(choices=get_message_choices(discussion), value=discussion.active_branch_id)
+
+    def handle_branch_change(discussion, selected_id):
+        if not discussion or not selected_id: return gr.skip(), gr.skip()
+        discussion.set_active_branch(selected_id)
+        return discussion, export_for_chatbot(discussion)
+
+    # --- Wire up Components ---
+    outputs_on_load = [client_state, discussion_state, discussion_selector, binding_selector, ollama_settings_group, openai_settings_group, ollama_host_input, ollama_model_selector, openai_api_key_input, openai_model_selector, system_prompt_input, chatbot, discussion_tree_display, branch_selector]
+    demo.load(on_load, outputs=outputs_on_load)
+    save_settings_button.click(handle_save_settings, [binding_selector, ollama_host_input, ollama_model_selector, openai_api_key_input, openai_model_selector], outputs_on_load)
+    binding_selector.change(lambda x: (gr.update(visible=x=='ollama'), gr.update(visible=x=='openai')), binding_selector, [ollama_settings_group, openai_settings_group])
+    refresh_ollama_button.click(list_ollama_models, ollama_host_input, ollama_model_selector)
+    system_prompt_input.blur(lambda d,t,f: d.set_system_prompt(t) and d.save_to_disk(os.path.join(DISCUSSIONS_DIR,f)) if d and f else None, [discussion_state, system_prompt_input, discussion_selector], [])
+
+    new_discussion_name.submit(handle_new_discussion, [client_state, new_discussion_name], [discussion_state, discussion_selector, chatbot, discussion_tree_display, branch_selector]).then(lambda: "", outputs=[new_discussion_name])
+    discussion_selector.change(handle_load_discussion, [client_state, discussion_selector], [discussion_state, system_prompt_input, chatbot, discussion_tree_display, branch_selector])
+    delete_discussion_button.click(handle_delete_discussion, [discussion_selector], outputs_on_load)
+
+    # --- CORRECTED WIRING FOR CHAT ---
+    chat_stream_event = user_input.submit(
+        fn=handle_chat_submit, 
+        inputs=[client_state, discussion_state, user_input, chatbot, discussion_selector], 
+        outputs=[chatbot],
+    )
+    # After the stream from handle_chat_submit is done, its input (discussion_state) will be updated.
+    # We can then pass that state to on_chat_finish.
+    chat_stream_event.then(
+        fn=on_chat_finish, 
+        inputs=[discussion_state], # The input is the state object that was modified by the previous function
+        outputs=[discussion_tree_display, branch_selector]
+    ).then(lambda: "", outputs=[user_input])
+    
+    send_button_stream_event = send_button.click(
+        fn=handle_chat_submit, 
+        inputs=[client_state, discussion_state, user_input, chatbot, discussion_selector], 
+        outputs=[chatbot]
+    )
+    send_button_stream_event.then(
+        fn=on_chat_finish, 
+        inputs=[discussion_state],
+        outputs=[discussion_tree_display, branch_selector]
+    ).then(lambda: "", outputs=[user_input])
+
+    branch_selector.change(handle_branch_change, [discussion_state, branch_selector], [discussion_state, chatbot])
+
+if __name__ == "__main__":
+    demo.launch()

{lollms_client-0.20.2 → lollms_client-0.20.4}/examples/internet_search_with_rag.py

@@ -173,8 +173,7 @@ if __name__ == "__main__":
             rag_top_k=2, # Get 2 search results per query
             rag_min_similarity_percent=50.0,
             streaming_callback=rag_streaming_callback,
-            n_predict=400,
-            rag_hop_query_generation_temperature=0.1
+            n_predict=400
         )
         print("\n--- End of Multi-Hop Search RAG (1 hop max) ---")
         ASCIIColors.magenta("\nMulti-Hop Search RAG (1 hop max) Final Output Structure:")

{lollms_client-0.20.2 → lollms_client-0.20.4}/lollms_client/__init__.py

@@ -7,7 +7,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 
 
-__version__ = "0.20.2" # Updated version
+__version__ = "0.20.4" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

{lollms_client-0.20.2 → lollms_client-0.20.4}/lollms_client/llm_bindings/llamacpp/__init__.py

@@ -635,6 +635,110 @@ class LlamaCppServerBinding(LollmsLLMBinding):
             error_message = f"Llama.cpp generation error: {str(ex)}"; trace_exception(ex)
             return {"status": False, "error": error_message}
 
+    def chat(self,
+             discussion: LollmsDiscussion,
+             branch_tip_id: Optional[str] = None,
+             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: Optional[int] = None,
+             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+             **generation_kwargs
+             ) -> Union[str, dict]:
+        """
+        Conduct a chat session with the llama.cpp server using a LollmsDiscussion object.
+
+        Args:
+            discussion (LollmsDiscussion): The discussion object containing the conversation history.
+            branch_tip_id (Optional[str]): The ID of the message to use as the tip of the conversation branch. Defaults to the active branch.
+            n_predict (Optional[int]): Maximum number of tokens to generate.
+            stream (Optional[bool]): Whether to stream the output.
+            temperature (float): Sampling temperature.
+            top_k (int): Top-k sampling parameter.
+            top_p (float): Top-p sampling parameter.
+            repeat_penalty (float): Penalty for repeated tokens.
+            repeat_last_n (int): Number of previous tokens to consider for repeat penalty.
+            seed (Optional[int]): Random seed for generation.
+            streaming_callback (Optional[Callable[[str, MSG_TYPE], None]]): Callback for streaming output.
+
+        Returns:
+            Union[str, dict]: The generated text or an error dictionary.
+        """
+        if not self.server_process or not self.server_process.is_healthy:
+            return {"status": "error", "message": "Llama.cpp server is not running or not healthy."}
+
+        # 1. Export the discussion to the OpenAI chat format, which llama.cpp server understands.
+        # This handles system prompts, user/assistant roles, and multi-modal content.
+        messages = discussion.export("openai_chat", branch_tip_id)
+
+        # 2. Build the generation payload for the server
+        payload = {
+            "messages": messages,
+            "max_tokens": n_predict,
+            "temperature": temperature,
+            "top_k": top_k,
+            "top_p": top_p,
+            "repeat_penalty": repeat_penalty,
+            "seed": seed,
+            "stream": stream,
+            **generation_kwargs # Pass any extra parameters
+        }
+        # Remove None values, as the API expects them to be absent
+        payload = {k: v for k, v in payload.items() if v is not None}
+        
+        endpoint = "/v1/chat/completions"
+        request_url = self._get_request_url(endpoint)
+        full_response_text = ""
+
+        try:
+            # 3. Make the request to the server
+            response = self.server_process.session.post(request_url, json=payload, stream=stream, timeout=self.server_args.get("generation_timeout", 300))
+            response.raise_for_status()
+
+            if stream:
+                for line in response.iter_lines():
+                    if not line: continue
+                    line_str = line.decode('utf-8').strip()
+                    if line_str.startswith('data: '): line_str = line_str[6:]
+                    if line_str == '[DONE]': break
+                    try:
+                        chunk_data = json.loads(line_str)
+                        chunk_content = chunk_data.get('choices', [{}])[0].get('delta', {}).get('content', '')
+                        if chunk_content:
+                            full_response_text += chunk_content
+                            if streaming_callback and not streaming_callback(chunk_content, MSG_TYPE.MSG_TYPE_CHUNK):
+                                ASCIIColors.info("Streaming callback requested stop.")
+                                response.close()
+                                break
+                    except json.JSONDecodeError:
+                        ASCIIColors.warning(f"Failed to decode JSON stream chunk: {line_str}")
+                        continue
+                return full_response_text
+            else: # Not streaming
+                response_data = response.json()
+                return response_data.get('choices', [{}])[0].get('message', {}).get('content', '')
+
+        except requests.exceptions.RequestException as e:
+            error_message = f"Llama.cpp server request error: {e}"
+            if e.response is not None:
+                try:
+                    error_details = e.response.json()
+                    error_message += f" - Details: {error_details.get('error', e.response.text)}"
+                except json.JSONDecodeError:
+                    error_message += f" - Response: {e.response.text[:200]}"
+            ASCIIColors.error(error_message)
+            return {"status": "error", "message": error_message}
+        except Exception as ex:
+            error_message = f"Llama.cpp generation error: {str(ex)}"
+            trace_exception(ex)
+            return {"status": "error", "message": error_message}
+        
     def tokenize(self, text: str) -> List[int]:
         if not self.server_process or not self.server_process.is_healthy: raise ConnectionError("Server not running.")
         try:

{lollms_client-0.20.2 → lollms_client-0.20.4}/lollms_client/llm_bindings/lollms/__init__.py

@@ -168,7 +168,108 @@ class LollmsLLMBinding(LollmsLLMBinding):
                     return {"status": False, "error": str(ex)}
             else:
                 return {"status": False, "error": response.text}
-    
+    def chat(self,
+             discussion: LollmsDiscussion,
+             branch_tip_id: Optional[str] = None,
+             n_predict: Optional[int] = None,
+             stream: Optional[bool] = None,
+             temperature: Optional[float] = None,
+             top_k: Optional[int] = None,
+             top_p: Optional[float] = None,
+             repeat_penalty: Optional[float] = None,
+             repeat_last_n: Optional[int] = None,
+             seed: Optional[int] = None,
+             n_threads: Optional[int] = None,
+             ctx_size: int | None = None,
+             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None
+             ) -> Union[str, dict]:
+        """
+        Conduct a chat session with a lollms-webui server using a LollmsDiscussion object.
+
+        Args:
+            discussion (LollmsDiscussion): The discussion object containing the conversation history.
+            branch_tip_id (Optional[str]): The ID of the message to use as the tip of the conversation branch. Defaults to the active branch.
+            ... (other parameters) ...
+
+        Returns:
+            Union[str, dict]: The generated text or an error dictionary.
+        """
+        # 1. Export the discussion to the lollms-native text format
+        prompt_text = discussion.export("lollms_text", branch_tip_id)
+        
+        # 2. Extract images from the LAST message of the branch
+        # lollms-webui's endpoint associates images with the final prompt
+        active_branch_id = branch_tip_id or discussion.active_branch_id
+        branch = discussion.get_branch(active_branch_id)
+        last_message = branch[-1] if branch else None
+        
+        image_data = []
+        if last_message and last_message.images:
+            # The endpoint expects a list of base64 strings.
+            # We will only process images of type 'base64'. URL types are not supported by this endpoint.
+            for img in last_message.images:
+                if img['type'] == 'base64':
+                    image_data.append(img['data'])
+                # Note: 'url' type images are ignored for this binding.
+
+        # 3. Determine endpoint and build payload
+        endpoint = "/lollms_generate_with_images" if image_data else "/lollms_generate"
+        url = f"{self.host_address}{endpoint}"
+        
+        headers = {'Content-Type': 'application/json'}
+        if self.service_key:
+            headers['Authorization'] = f'Bearer {self.service_key}'
+
+        data = {
+            "prompt": prompt_text,
+            "model_name": self.model_name,
+            "personality": self.personality,
+            "n_predict": n_predict,
+            "stream": stream,
+            "temperature": temperature,
+            "top_k": top_k,
+            "top_p": top_p,
+            "repeat_penalty": repeat_penalty,
+            "repeat_last_n": repeat_last_n,
+            "seed": seed,
+            "n_threads": n_threads
+        }
+        if image_data:
+            data["images"] = image_data
+
+        # 4. Make the request (logic copied and adapted from generate_text)
+        try:
+            response = requests.post(
+                url, 
+                json=data, 
+                headers=headers, 
+                stream=stream,
+                verify=self.verify_ssl_certificate
+            )
+            response.raise_for_status() # Raise an exception for bad status codes
+
+            if not stream:
+                return response.text.strip()
+            else:
+                full_response_text = ""
+                for line in response.iter_lines():
+                    if line:
+                        chunk = line.decode("utf-8")
+                        full_response_text += chunk
+                        if streaming_callback:
+                            if not streaming_callback(chunk, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break
+                # Clean up potential quotes from some streaming formats
+                if full_response_text.startswith('"') and full_response_text.endswith('"'):
+                    full_response_text = full_response_text[1:-1]
+                return full_response_text.rstrip('!')
+
+        except requests.exceptions.RequestException as e:
+            error_message = f"lollms-webui request error: {e}"
+            return {"status": "error", "message": error_message}
+        except Exception as ex:
+            error_message = f"lollms-webui generation error: {str(ex)}"
+            return {"status": "error", "message": error_message}    
     def tokenize(self, text: str) -> list:
         """
         Tokenize the input text into a list of tokens using the /lollms_tokenize endpoint.

{lollms_client-0.20.2 → lollms_client-0.20.4}/lollms_client/llm_bindings/ollama/__init__.py

@@ -6,6 +6,7 @@ from lollms_client.lollms_types import MSG_TYPE
 # encode_image is not strictly needed if ollama-python handles paths, but kept for consistency if ever needed.
 # from lollms_client.lollms_utilities import encode_image 
 from lollms_client.lollms_types import ELF_COMPLETION_FORMAT
+from lollms_client.lollms_discussion import LollmsDiscussion
 from typing import Optional, Callable, List, Union, Dict
 
 from ascii_colors import ASCIIColors, trace_exception
@@ -258,6 +259,104 @@ class OllamaBinding(LollmsLLMBinding):
             trace_exception(ex)
             return {"status": False, "error": error_message}
     
+    def chat(self,
+             discussion: LollmsDiscussion,
+             branch_tip_id: Optional[str] = None,
+             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: Optional[int] = None,
+             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None
+             ) -> Union[str, dict]:
+        """
+        Conduct a chat session with the Ollama model using a LollmsDiscussion object.
+
+        Args:
+            discussion (LollmsDiscussion): The discussion object containing the conversation history.
+            branch_tip_id (Optional[str]): The ID of the message to use as the tip of the conversation branch. Defaults to the active branch.
+            n_predict (Optional[int]): Maximum number of tokens to generate.
+            stream (Optional[bool]): Whether to stream the output.
+            temperature (float): Sampling temperature.
+            top_k (int): Top-k sampling parameter.
+            top_p (float): Top-p sampling parameter.
+            repeat_penalty (float): Penalty for repeated tokens.
+            repeat_last_n (int): Number of previous tokens to consider for repeat penalty.
+            seed (Optional[int]): Random seed for generation.
+            n_threads (Optional[int]): Number of threads to use.
+            ctx_size (Optional[int]): Context size override for this generation.
+            streaming_callback (Optional[Callable[[str, MSG_TYPE], None]]): Callback for streaming output.
+
+        Returns:
+            Union[str, dict]: The generated text or an error dictionary.
+        """
+        if not self.ollama_client:
+             return {"status": "error", "message": "Ollama client not initialized."}
+
+        # 1. Export the discussion to the Ollama chat format
+        # This handles system prompts, user/assistant roles, and base64-encoded images.
+        messages = discussion.export("ollama_chat", branch_tip_id)
+
+        # 2. Build the generation options dictionary
+        options = {
+            'num_predict': n_predict,
+            'temperature': float(temperature),
+            'top_k': top_k,
+            'top_p': top_p,
+            'repeat_penalty': repeat_penalty,
+            'repeat_last_n': repeat_last_n,
+            'seed': seed,
+            'num_thread': n_threads,
+            'num_ctx': ctx_size,
+        }
+        # Remove None values, as ollama-python expects them to be absent
+        options = {k: v for k, v in options.items() if v is not None}
+
+        full_response_text = ""
+
+        try:
+            # 3. Call the Ollama API
+            if stream:
+                response_stream = self.ollama_client.chat(
+                    model=self.model_name,
+                    messages=messages,
+                    stream=True,
+                    options=options if options else None
+                )
+                for chunk in response_stream:
+                    chunk_content = chunk.get('message', {}).get('content', '')
+                    if chunk_content:
+                        full_response_text += chunk_content
+                        if streaming_callback:
+                            if not streaming_callback(chunk_content, MSG_TYPE.MSG_TYPE_CHUNK):
+                                break
+                return full_response_text
+            else: # Not streaming
+                response_dict = self.ollama_client.chat(
+                    model=self.model_name,
+                    messages=messages,
+                    stream=False,
+                    options=options if options else None
+                )
+                return response_dict.get('message', {}).get('content', '')
+
+        except ollama.ResponseError as e:
+            error_message = f"Ollama API ResponseError: {e.error or 'Unknown error'} (status code: {e.status_code})"
+            ASCIIColors.error(error_message)
+            return {"status": "error", "message": error_message}
+        except ollama.RequestError as e:
+            error_message = f"Ollama API RequestError: {str(e)}"
+            ASCIIColors.error(error_message)
+            return {"status": "error", "message": error_message}
+        except Exception as ex:
+            error_message = f"An unexpected error occurred: {str(ex)}"
+            trace_exception(ex)
+            return {"status": "error", "message": error_message}    
     def tokenize(self, text: str) -> list:
         """
         Tokenize the input text into a list of characters.