lollms-client 0.33.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

examples/function_calling_with_local_custom_mcp.py

@@ -1,250 +0,0 @@
-from lollms_client import LollmsClient, MSG_TYPE
-from ascii_colors import ASCIIColors, trace_exception
-from pathlib import Path
-import json # For pretty printing results
-
-# --- Configuration ---
-# LLM Configuration
-LLM_BINDING_NAME = "ollama"
-OLLAMA_HOST_ADDRESS = "http://localhost:11434" # Default Ollama host
-# Ensure you have a model capable of following instructions and generating JSON.
-# Mistral, Llama 3, or Phi-3 variants often work well.
-OLLAMA_MODEL_NAME = "mistral-nemo:latest" # Or "llama3:latest", "phi3:latest" - ensure it's pulled
-
-# Local MCP Binding Configuration
-# This path should point to the directory containing your tool subdirectories
-# (e.g., 'get_weather/', 'sum_numbers/')
-# For this example, we assume 'temp_mcp_tools_for_test' is in the parent directory
-# of this examples folder.
-TOOLS_FOLDER = Path(__file__).parent.parent / "temp_mcp_tools_for_test"
-
-# Function Calling Parameters
-MAX_LLM_ITERATIONS_FOR_TOOL_CALLS = 3 # How many times LLM can decide to call a tool in a sequence
-MAX_TOOL_CALLS_PER_TURN = 2 # Max distinct tools executed per user prompt
-
-# --- Helper to Create Dummy Tools (if they don't exist) ---
-def ensure_dummy_tools_exist(base_tools_dir: Path):
-    if not base_tools_dir.exists():
-        ASCIIColors.info(f"Creating dummy tools directory: {base_tools_dir}")
-        base_tools_dir.mkdir(parents=True, exist_ok=True)
-
-    tool_defs = {
-        "get_weather": {
-            "mcp": {
-                "name": "get_weather",
-                "description": "Fetches the current weather for a given city.",
-                "input_schema": {
-                    "type": "object",
-                    "properties": {
-                        "city": {"type": "string", "description": "The city name."},
-                        "unit": {"type": "string", "enum": ["celsius", "fahrenheit"], "default": "celsius"}
-                    },
-                    "required": ["city"]
-                },
-                "output_schema": {
-                    "type": "object",
-                    "properties": {
-                        "temperature": {"type": "number"}, "condition": {"type": "string"}, "unit": {"type": "string"}
-                    }
-                }
-            },
-            "py": """
-import random
-def execute(params: dict) -> dict:
-    city = params.get("city")
-    unit = params.get("unit", "celsius")
-    if not city: return {"error": "City not provided"}
-    conditions = ["sunny", "cloudy", "rainy", "snowy", "windy"]
-    temp = random.randint(-5 if unit == "celsius" else 23, 30 if unit == "celsius" else 86)
-    return {"temperature": temp, "condition": random.choice(conditions), "unit": unit}
-"""
-        },
-        "sum_numbers": {
-            "mcp": {
-                "name": "sum_numbers",
-                "description": "Calculates the sum of a list of numbers.",
-                "input_schema": {
-                    "type": "object",
-                    "properties": {"numbers": {"type": "array", "items": {"type": "number"}}},
-                    "required": ["numbers"]
-                },
-                "output_schema": {"type": "object", "properties": {"sum": {"type": "number"}}}
-            },
-            "py": """
-def execute(params: dict) -> dict:
-    numbers = params.get("numbers", [])
-    if not isinstance(numbers, list) or not all(isinstance(n, (int, float)) for n in numbers):
-        return {"error": "Invalid input: 'numbers' must be a list of numbers."}
-    return {"sum": sum(numbers)}
-"""
-        }
-    }
-
-    for tool_name, files_content in tool_defs.items():
-        tool_dir = base_tools_dir / tool_name
-        tool_dir.mkdir(exist_ok=True)
-        
-        mcp_file = tool_dir / f"{tool_name}.mcp.json"
-        py_file = tool_dir / f"{tool_name}.py"
-
-        if not mcp_file.exists():
-            with open(mcp_file, "w") as f:
-                json.dump(files_content["mcp"], f, indent=2)
-            ASCIIColors.info(f"Created MCP definition for {tool_name}")
-        
-        if not py_file.exists():
-            with open(py_file, "w") as f:
-                f.write(files_content["py"])
-            ASCIIColors.info(f"Created Python code for {tool_name}")
-
-# --- Callback for streaming ---
-def function_calling_stream_callback(chunk: str, msg_type: MSG_TYPE, metadata: dict = None, turn_history: list = None) -> bool:
-    """
-    Callback to handle streamed output during function calling.
-    """
-    if msg_type == MSG_TYPE.MSG_TYPE_CHUNK:  # LLM generating text
-        ASCIIColors.success(chunk, end="", flush=True)
-    elif msg_type == MSG_TYPE.MSG_TYPE_STEP_START:
-        step_type = metadata.get("type", "step") if metadata else "step"
-        step_info = metadata.get("tool_name", "") if metadata and "tool_name" in metadata else chunk
-        ASCIIColors.info(f">> Starting {step_type}: {step_info}", flush=True)
-    elif msg_type == MSG_TYPE.MSG_TYPE_STEP_END:
-        step_type = metadata.get("type", "step") if metadata else "step"
-        step_info = metadata.get("tool_name", "") if metadata and "tool_name" in metadata else chunk
-        if metadata and "result" in metadata:
-            ASCIIColors.success(f"<< Finished {step_type}: {step_info} -> Result: {json.dumps(metadata['result'])}", flush=True)
-        else:
-            ASCIIColors.success(f"<< Finished {step_type}: {step_info}", flush=True)
-    elif msg_type == MSG_TYPE.MSG_TYPE_INFO:
-        if metadata and metadata.get("type") == "tool_call_request":
-            ASCIIColors.info(f"AI requests to call tool: {metadata.get('name')} with params: {metadata.get('params')}", flush=True)
-        else:
-            ASCIIColors.info(f"INFO: {chunk}", flush=True)
-    elif msg_type == MSG_TYPE.MSG_TYPE_EXCEPTION:
-        ASCIIColors.error(f"ERROR in stream: {chunk}", flush=True)
-
-    # Optional debug info:
-    # ASCIIColors.info(f"DEBUG Turn History (so far): {turn_history}")
-    return True
-
-
-
-def run_function_calling_example():
-    ASCIIColors.red("--- LoLLMs Client with Local MCP Function Calling Example ---")
-    
-    ensure_dummy_tools_exist(TOOLS_FOLDER) # Make sure our example tools are present
-
-    try:
-        ASCIIColors.magenta("\n1. Initializing LollmsClient...")
-        # MCP binding config is passed directly to the binding constructor
-        mcp_binding_configuration = {"tools_folder_path": str(TOOLS_FOLDER)}
-        
-        lc = LollmsClient(
-            binding_name=LLM_BINDING_NAME,
-            host_address=OLLAMA_HOST_ADDRESS,
-            model_name=OLLAMA_MODEL_NAME,
-            mcp_binding_name="local_mcp", # Activate the LocalMCP binding
-            mcp_binding_config=mcp_binding_configuration, # Pass its specific config
-            # Optional: Configure default LLM generation params if needed
-            temperature=0.2, # Lower temp for more focused tool decisions / final answer
-            n_predict=1024
-        )
-        ASCIIColors.green("LollmsClient initialized successfully.")
-        if lc.mcp:
-            ASCIIColors.info(f"MCP Binding '{lc.mcp.binding_name}' loaded.")
-            discovered_tools_on_init = lc.mcp.discover_tools()
-            ASCIIColors.info(f"Tools discovered by MCP binding on init: {[t['name'] for t in discovered_tools_on_init]}")
-        else:
-            ASCIIColors.error("MCP binding was not loaded correctly. Aborting.")
-            return
-
-        # --- Example Interaction 1: Weather Request ---
-        ASCIIColors.magenta("\n2. Example 1: Asking for weather")
-        user_prompt_weather = "What's the weather like in Paris today, and can you tell me in Fahrenheit?"
-        ASCIIColors.blue(f"User: {user_prompt_weather}")
-        ASCIIColors.yellow(f"AI thinking and interacting with tools (streaming output):")
-
-        weather_result = lc.generate_with_mcp(
-            prompt=user_prompt_weather,
-            # tools=None, # Let it discover from the binding
-            max_tool_calls=MAX_TOOL_CALLS_PER_TURN,
-            max_llm_iterations=MAX_LLM_ITERATIONS_FOR_TOOL_CALLS,
-            streaming_callback=function_calling_stream_callback,
-            # interactive_tool_execution=True # Uncomment to confirm tool calls
-        )
-        print("\n--- End of AI Response for Weather ---")
-        if weather_result["error"]:
-            ASCIIColors.error(f"Error in weather example: {weather_result['error']}")
-        else:
-            ASCIIColors.cyan(f"\nFinal Answer (Weather): {weather_result['final_answer']}")
-        ASCIIColors.info("\nTool Calls Made (Weather Example):")
-        for tc in weather_result["tool_calls"]:
-            print(f"  - Tool: {tc['name']}, Params: {tc['params']}, Result: {json.dumps(tc['result'])}")
-
-
-        # --- Example Interaction 2: Summation Request ---
-        ASCIIColors.magenta("\n3. Example 2: Asking to sum numbers")
-        user_prompt_sum = "Hey, can you please calculate the sum of 15.5, 25, and -5.5 for me?"
-        ASCIIColors.blue(f"User: {user_prompt_sum}")
-        ASCIIColors.yellow(f"AI thinking and interacting with tools (streaming output):")
-
-        sum_result_data = lc.generate_with_mcp(
-            prompt=user_prompt_sum,
-            max_tool_calls=MAX_TOOL_CALLS_PER_TURN,
-            max_llm_iterations=MAX_LLM_ITERATIONS_FOR_TOOL_CALLS,
-            streaming_callback=function_calling_stream_callback
-        )
-        print("\n--- End of AI Response for Sum ---")
-        if sum_result_data["error"]:
-            ASCIIColors.error(f"Error in sum example: {sum_result_data['error']}")
-        else:
-            ASCIIColors.cyan(f"\nFinal Answer (Sum): {sum_result_data['final_answer']}")
-        ASCIIColors.info("\nTool Calls Made (Sum Example):")
-        for tc in sum_result_data["tool_calls"]:
-            print(f"  - Tool: {tc['name']}, Params: {tc['params']}, Result: {json.dumps(tc['result'])}")
-
-
-        # --- Example Interaction 3: Multi-step (hypothetical, weather then sum) ---
-        ASCIIColors.magenta("\n4. Example 3: Multi-step (Weather, then maybe sum if AI decides)")
-        user_prompt_multi = "What's the weather in Berlin? And also, what's 100 + 200 + 300?"
-        ASCIIColors.blue(f"User: {user_prompt_sum}")
-        ASCIIColors.yellow(f"AI thinking and interacting with tools (streaming output):")
-
-        multi_result_data = lc.generate_with_mcp(
-            prompt=user_prompt_multi,
-            max_tool_calls=MAX_TOOL_CALLS_PER_TURN, # Allow up to 2 different tools
-            max_llm_iterations=MAX_LLM_ITERATIONS_FOR_TOOL_CALLS +1, # Allow a bit more LLM thinking
-            streaming_callback=function_calling_stream_callback
-        )
-        print("\n--- End of AI Response for Multi-step ---")
-        if multi_result_data["error"]:
-            ASCIIColors.error(f"Error in multi-step example: {multi_result_data['error']}")
-        else:
-            ASCIIColors.cyan(f"\nFinal Answer (Multi-step): {multi_result_data['final_answer']}")
-        ASCIIColors.info("\nTool Calls Made (Multi-step Example):")
-        for tc in multi_result_data["tool_calls"]:
-            print(f"  - Tool: {tc['name']}, Params: {tc['params']}, Result: {json.dumps(tc['result'])}")
-
-
-    except ValueError as ve: # Catch init errors
-        ASCIIColors.error(f"Initialization Error: {ve}")
-        trace_exception(ve)
-    except ConnectionRefusedError:
-        ASCIIColors.error(f"Connection refused. Is the Ollama server running at {OLLAMA_HOST_ADDRESS}?")
-    except Exception as e:
-        ASCIIColors.error(f"An unexpected error occurred: {e}")
-        trace_exception(e)
-    finally:
-        ASCIIColors.info(f"If dummy tools were created, they are in: {TOOLS_FOLDER.resolve()}")
-        # Consider cleaning up TOOLS_FOLDER if it was created purely for this test run
-        # For this example, we'll leave them.
-        # import shutil
-        # if "ensure_dummy_tools_exist" in globals() and TOOLS_FOLDER.exists() and "temp_mcp_tools_for_test" in str(TOOLS_FOLDER):
-        #     if input(f"Clean up dummy tools at {TOOLS_FOLDER}? (y/n): ").lower() == 'y':
-        #         shutil.rmtree(TOOLS_FOLDER)
-        #         ASCIIColors.info("Cleaned up dummy tools folder.")
-
-    ASCIIColors.red("\n--- Example Finished ---")
-
-if __name__ == "__main__":
-    run_function_calling_example()

examples/generate_a_benchmark_for_safe_store.py

@@ -1,89 +0,0 @@
-from lollms_client import LollmsClient
-from ascii_colors import ASCIIColors, trace_exception, ProgressBar
-import pipmaster as pm
-pm.ensure_packages(["datasets"])
-#assuming you have an active lollms_webui instance running
-#you can also use ollama or openai or any other lollmc_client binding 
-lc = LollmsClient()
-
-from datasets import load_dataset
-import json
-# 1. Define the dataset name
-dataset_name = "agentlans/high-quality-english-sentences"
-
-try:
-    # 2. Load the dataset
-    # This dataset only has a 'train' split by default.
-    # If a dataset had multiple splits (e.g., 'train', 'validation', 'test'),
-    # load_dataset() would return a DatasetDict.
-    # We can directly access the 'train' split.
-    dataset = load_dataset(dataset_name, split='train')
-    print(f"Dataset loaded successfully: {dataset_name}")
-    print(f"Dataset structure: {dataset}")
-
-    # 3. Extract the sentences into a list
-    # The sentences are in a column likely named 'text' (common for text datasets).
-    # Let's inspect the features to be sure.
-    print(f"Dataset features: {dataset.features}")
-
-    # Assuming the column containing sentences is 'text'
-    # This is standard for many text datasets on Hugging Face.
-    # dataset['text'] directly gives a list of all values in the 'text' column.
-    sentences_list = dataset['text']
-
-    # If you want to be absolutely sure it's a Python list (it usually is or acts like one):
-    # sentences_list = list(dataset['text'])
-
-    # 4. Verify and print some examples
-    print(f"\nSuccessfully extracted {len(sentences_list)} sentences into a list.")
-
-    if sentences_list:
-        print("\nFirst 5 sentences:")
-        for i in range(min(5, len(sentences_list))):
-            print(f"{i+1}. {sentences_list[i]}")
-
-        print("\nLast 5 sentences:")
-        for i in range(max(0, len(sentences_list) - 5), len(sentences_list)):
-            print(f"{len(sentences_list) - (len(sentences_list) - 1 - i)}. {sentences_list[i]}")
-    else:
-        print("The list of sentences is empty.")
-
-except Exception as e:
-    print(f"An error occurred: {e}")
-    print("Please ensure you have an active internet connection and the `datasets` library is installed.")
-    print("Dataset name might be incorrect or the dataset might require authentication or specific configurations.")
-
-entries = []
-for sentence in ProgressBar(sentences_list, desc="Processing Items"):
-    prompt = f"""Given the following text chunk:
-    "{sentence}"
-
-    Generate a JSON object with the following keys and corresponding string values:
-    - "id": A title to the sentence being processed
-    - "highly_similar": A paraphrase of the original chunk, maintaining the core meaning but using different wording and sentence structure.
-    - "related": A sentence or short paragraph that is on the same general topic as the original chunk but discusses a different aspect or a related concept. It should not be a direct paraphrase.
-    - "dissimilar": A sentence or short paragraph on a completely unrelated topic.
-    - "question_form": A question that encapsulates the main idea or asks about a key aspect of the original chunk.
-    - "negation": A sentence that negates the main assertion or a key aspect of the original chunk, while still being topically relevant if possible (e.g., not "The sky is not blue" if the topic is computers).
-
-    Ensure the output is ONLY a valid JSON object. Example:
-    {{
-    "id": "...",
-    "highly_similar": "...",
-    "related": "...",
-    "dissimilar": "...",
-    "question_form": "...",
-    "negation": "..."
-    }}
-
-    JSON object:
-    """
-    try:
-        output = lc.generate_code(prompt)
-        entry = json.loads(output)
-        entry["query"]=sentence
-        entries.append(entry)
-        with open("benchmark_db.json","w") as f:
-            json.dump(entries, f, indent=4)
-    except Exception as ex:
-        trace_exception(ex)

examples/generate_and_speak/generate_and_speak.py

@@ -1,251 +0,0 @@
-# lollms_client/examples/text_and_speech_demo/generate_and_speak.py
-from pathlib import Path
-import time
-import argparse
-
-# Ensure pygame is installed for this example
-try:
-    import pipmaster as pm
-    pm.ensure_packages(["pygame"])
-    import pygame
-    PYGAME_AVAILABLE = True
-except ImportError:
-    print("Pygame not found or pipmaster failed. Please install it manually: pip install pygame")
-    PYGAME_AVAILABLE = False
-except Exception as e:
-    print(f"Could not ensure pygame: {e}")
-    PYGAME_AVAILABLE = False
-
-from lollms_client import LollmsClient, MSG_TYPE
-from ascii_colors import ASCIIColors, trace_exception
-
-# --- Configuration ---
-SPEECH_OUTPUT_DIR = Path(__file__).parent / "speech_output"
-SPEECH_OUTPUT_DIR.mkdir(exist_ok=True)
-
-# Default path for Piper voices relative to this example script for convenience
-DEFAULT_PIPER_VOICES_SUBDIR = Path(__file__).parent / "piper_voices_for_demo"
-DEFAULT_PIPER_VOICE_FILENAME = "en_US-lessac-medium.onnx" # A common, good quality English voice
-
-def text_stream_callback(chunk: str, message_type: MSG_TYPE, params: dict = None, metadata: list = None) -> bool:
-    if message_type == MSG_TYPE.MSG_TYPE_CHUNK:
-        print(chunk, end="", flush=True)
-    elif message_type == MSG_TYPE.MSG_TYPE_STEP_START:
-        ASCIIColors.yellow(f"\n>> Starting step: {chunk}")
-    elif message_type == MSG_TYPE.MSG_TYPE_STEP_END:
-        ASCIIColors.green(f"\n<< Finished step: {chunk}")
-    return True
-
-def ensure_default_piper_voice_for_demo(voices_dir: Path, voice_filename: str):
-    """Helper to download a default Piper voice if not present for the demo."""
-    voices_dir.mkdir(exist_ok=True)
-    onnx_path = voices_dir / voice_filename
-    json_path = voices_dir / f"{voice_filename}.json"
-
-    if not onnx_path.exists() or not json_path.exists():
-        ASCIIColors.info(f"Default Piper test voice '{voice_filename}' not found in {voices_dir}. Attempting to download...")
-        try:
-            import requests
-            # Construct URLs (assuming en_US/lessac/medium structure)
-            voice_parts = voice_filename.split('-') # e.g., ['en_US', 'lessac', 'medium.onnx']
-            lang_code = voice_parts[0].split('_')[0] # en
-            voice_name_path = "/".join(voice_parts[0:2]) # en_US/lessac
-            quality_path = voice_parts[2].split('.')[0] # medium
-
-            # Base URL for Piper voices on Hugging Face
-            PIPER_VOICES_HF_BASE_URL = "https://huggingface.co/rhasspy/piper-voices/resolve/main/"
-
-            onnx_url = f"{PIPER_VOICES_HF_BASE_URL}{lang_code}/{voice_name_path}/{quality_path}/{voice_filename}"
-            json_url = f"{PIPER_VOICES_HF_BASE_URL}{lang_code}/{voice_name_path}/{quality_path}/{voice_filename}.json"
-
-
-            if not onnx_path.exists():
-                ASCIIColors.info(f"Downloading {onnx_url} to {onnx_path}")
-                r_onnx = requests.get(onnx_url, stream=True)
-                r_onnx.raise_for_status()
-                with open(onnx_path, 'wb') as f:
-                    for chunk in r_onnx.iter_content(chunk_size=8192): f.write(chunk)
-            
-            if not json_path.exists():
-                ASCIIColors.info(f"Downloading {json_url} to {json_path}")
-                r_json = requests.get(json_url)
-                r_json.raise_for_status()
-                with open(json_path, 'w', encoding='utf-8') as f: f.write(r_json.text)
-            ASCIIColors.green(f"Default Piper test voice '{voice_filename}' downloaded successfully to {voices_dir}.")
-            return True
-        except Exception as e_download:
-            ASCIIColors.error(f"Failed to download default Piper test voice '{voice_filename}': {e_download}")
-            ASCIIColors.warning(f"Please manually download '{voice_filename}' and '{voice_filename}.json' "
-                                f"from rhasspy.github.io/piper-voices/ or Hugging Face "
-                                f"and place them in {voices_dir.resolve()}")
-            return False
-    return True
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Generate text with an LLM and synthesize it to speech using LOLLMS.")
-    # LLM Arguments
-    parser.add_argument(
-        "--llm_binding", type=str, default="ollama", choices=["ollama", "openai", "lollms", "llamacpp", "pythonllamacpp", "transformers", "vllm"],
-        help="The LLM binding to use for text generation."
-    )
-    parser.add_argument(
-        "--llm_model", type=str, default="mistral",
-        help="Model name or path for the LLM binding."
-    )
-    parser.add_argument("--llm_host", type=str, default=None, help="Host address for server-based LLM bindings.")
-    parser.add_argument("--models_path", type=str, default=None, help="Path to models directory for local LLM bindings.")
-    parser.add_argument("--openai_key", type=str, default=None, help="OpenAI API key.")
-
-    # TTS Arguments
-    parser.add_argument(
-        "--tts_binding", type=str, default="bark", choices=["bark", "lollms", "xtts", "piper"],
-        help="The TTS binding to use for speech synthesis."
-    )
-    # Bark specific
-    parser.add_argument("--bark_model", type=str, default="suno/bark-small", help="Bark model ID for TTS.")
-    parser.add_argument("--bark_voice_preset", type=str, default="v2/en_speaker_6", help="Bark voice preset.")
-    # XTTS specific
-    parser.add_argument("--xtts_model", type=str, default="tts_models/multilingual/multi-dataset/xtts_v2", help="XTTS model identifier for Coqui TTS.")
-    parser.add_argument("--xtts_speaker_wav", type=str, default=None, help="Path to speaker WAV for XTTS voice cloning.")
-    parser.add_argument("--xtts_language", type=str, default="en", help="Language for XTTS.")
-    # Piper specific
-    parser.add_argument("--piper_default_voice_model_path", type=str, default=None, help="Path to the default .onnx Piper voice model.")
-    parser.add_argument("--piper_voices_dir", type=str, default=str(DEFAULT_PIPER_VOICES_SUBDIR), help="Directory containing Piper voice models.")
-    parser.add_argument("--piper_voice_file", type=str, default=DEFAULT_PIPER_VOICE_FILENAME, help="Filename of the Piper voice to use from piper_voices_dir (e.g., en_US-ryan-medium.onnx).")
-
-    # Common TTS/LLM args
-    parser.add_argument("--tts_host", type=str, default=None, help="Host address for server-based TTS bindings (e.g., lollms TTS).")
-    parser.add_argument("--device", type=str, default=None, choices=["cpu", "cuda", "mps", None], help="Device for local TTS/LLM models.")
-    args = parser.parse_args()
-
-    ASCIIColors.red("--- LOLLMS Text Generation and Speech Synthesis Demo ---")
-    ASCIIColors.info(f"Using LLM Binding: {args.llm_binding} (Model: {args.llm_model})")
-    ASCIIColors.info(f"Using TTS Binding: {args.tts_binding}")
-    if args.tts_binding == "bark":
-        ASCIIColors.info(f"  Bark Model: {args.bark_model}, Voice Preset: {args.bark_voice_preset}")
-    elif args.tts_binding == "xtts":
-        ASCIIColors.info(f"  XTTS Model: {args.xtts_model}, Speaker WAV: {args.xtts_speaker_wav or 'Default in binding'}, Lang: {args.xtts_language}")
-    elif args.tts_binding == "piper":
-        ASCIIColors.info(f"  Piper Voices Dir: {args.piper_voices_dir}, Voice File: {args.piper_voice_file}")
-        # Ensure default Piper voice for demo if Piper is selected and no specific default path is given
-        if not args.piper_default_voice_model_path:
-            ensure_default_piper_voice_for_demo(Path(args.piper_voices_dir), args.piper_voice_file)
-            args.piper_default_voice_model_path = str(Path(args.piper_voices_dir) / args.piper_voice_file)
-
-
-    llm_binding_config = {}
-    if args.llm_binding == "openai" and args.openai_key: llm_binding_config["service_key"] = args.openai_key
-    elif args.llm_binding in ["llamacpp", "pythonllamacpp", "transformers", "vllm"]:
-        if args.device: llm_binding_config["device"] = args.device
-        if args.llm_binding == "pythonllamacpp": llm_binding_config["n_gpu_layers"] = -1 if args.device == "cuda" else 0
-
-    tts_binding_config = {"device": args.device}
-    if args.tts_binding == "bark":
-        tts_binding_config["model_name"] = args.bark_model
-        tts_binding_config["default_voice"] = args.bark_voice_preset
-    elif args.tts_binding == "xtts":
-        tts_binding_config["model_name"] = args.xtts_model
-        tts_binding_config["default_speaker_wav"] = args.xtts_speaker_wav
-        tts_binding_config["default_language"] = args.xtts_language
-    elif args.tts_binding == "piper":
-        tts_binding_config["default_voice_model_path"] = args.piper_default_voice_model_path
-        tts_binding_config["piper_voices_dir"] = args.piper_voices_dir
-    elif args.tts_binding == "lollms":
-        tts_binding_config["model_name"] = "default_lollms_voice" # Placeholder, server handles actual voice
-
-    lollms_client = None
-    try:
-        ASCIIColors.magenta("Initializing LollmsClient...")
-        lollms_client = LollmsClient(
-            binding_name=args.llm_binding, model_name=args.llm_model,
-            host_address=args.llm_host, models_path=args.models_path,
-            llm_binding_config=llm_binding_config,
-            tts_binding_name=args.tts_binding, tts_host_address=args.tts_host,
-            tts_binding_config=tts_binding_config,
-            verify_ssl_certificate=False
-        )
-        ASCIIColors.green("LollmsClient initialized.")
-    except Exception as e:
-        ASCIIColors.error(f"Failed to initialize LollmsClient: {e}"); trace_exception(e)
-        return
-
-    generated_text = ""
-    text_prompt = "Craft a very short, cheerful message about the joy of discovery."
-    ASCIIColors.cyan(f"\n--- Generating Text (Prompt: '{text_prompt[:50]}...') ---")
-    if not lollms_client.binding:
-        ASCIIColors.error("LLM binding not available."); return
-    try:
-        print(f"{ASCIIColors.YELLOW}AI is thinking: {ASCIIColors.RESET}", end="")
-        generated_text = lollms_client.generate_text(
-            prompt=text_prompt, n_predict=100, stream=True,
-            streaming_callback=text_stream_callback, temperature=0.7
-        )
-        print("\n"); ASCIIColors.green("Text generation complete.")
-        ASCIIColors.magenta("Generated Text:\n"); ASCIIColors.yellow(generated_text)
-    except Exception as e:
-        ASCIIColors.error(f"Text generation failed: {e}"); trace_exception(e); return
-    if not generated_text:
-        ASCIIColors.warning("LLM did not generate any text."); return
-
-    speech_file_path = None
-    ASCIIColors.cyan(f"\n--- Synthesizing Speech (using {args.tts_binding}) ---")
-    if not lollms_client.tts:
-        ASCIIColors.error("TTS binding not available."); return
-    try:
-        tts_call_kwargs = {}
-        if args.tts_binding == "bark":
-            # For Bark, 'voice' in generate_audio is the voice_preset.
-            # If not using the default from init, pass it here.
-            # tts_call_kwargs['voice'] = args.bark_voice_preset 
-            pass # Uses default_voice from init if args.bark_voice_preset not specified to override
-        elif args.tts_binding == "xtts":
-            tts_call_kwargs['language'] = args.xtts_language
-            # 'voice' for XTTS is the speaker_wav path. If not using default from init, pass here.
-            # tts_call_kwargs['voice'] = args.xtts_speaker_wav 
-        elif args.tts_binding == "piper":
-            # 'voice' for Piper is the .onnx filename.
-            tts_call_kwargs['voice'] = args.piper_voice_file
-            # Example Piper specific param:
-            # tts_call_kwargs['length_scale'] = 1.0 
-
-        audio_bytes = lollms_client.tts.generate_audio(text=generated_text, **tts_call_kwargs)
-
-        if audio_bytes:
-            filename_stem = f"speech_output_{args.llm_binding}_{args.tts_binding}"
-            speech_file_path = SPEECH_OUTPUT_DIR / f"{filename_stem.replace('/', '_')}.wav"
-            with open(speech_file_path, "wb") as f: f.write(audio_bytes)
-            ASCIIColors.green(f"Speech synthesized and saved to: {speech_file_path}")
-        elif args.tts_binding == "lollms":
-            ASCIIColors.warning("LOLLMS TTS binding returned empty bytes. Server might have saved file if 'fn' was used.")
-            speech_file_path = None
-        else:
-            ASCIIColors.warning("Speech synthesis returned empty bytes."); speech_file_path = None
-    except Exception as e:
-        ASCIIColors.error(f"Speech synthesis failed: {e}"); trace_exception(e); return
-
-    if speech_file_path and PYGAME_AVAILABLE:
-        ASCIIColors.magenta("\n--- Playing Synthesized Speech ---")
-        try:
-            pygame.mixer.init()
-            speech_sound = pygame.mixer.Sound(str(speech_file_path))
-            ASCIIColors.cyan("Playing audio... Press Ctrl+C in console to stop playback early.")
-            speech_sound.play()
-            while pygame.mixer.get_busy():
-                pygame.time.Clock().tick(10)
-                for event in pygame.event.get():
-                    if event.type == pygame.QUIT: pygame.mixer.stop(); break
-            ASCIIColors.green("Playback finished.")
-        except pygame.error as e: ASCIIColors.warning(f"Could not play audio with pygame: {e}")
-        except KeyboardInterrupt: pygame.mixer.stop(); ASCIIColors.yellow("\nPlayback interrupted.")
-        finally: pygame.quit()
-    elif not PYGAME_AVAILABLE:
-        ASCIIColors.warning("Pygame is not available for playback.")
-        if speech_file_path: ASCIIColors.info(f"Generated speech: {speech_file_path.resolve()}")
-    elif not speech_file_path:
-         ASCIIColors.warning("No speech file generated/path unknown. Skipping playback.")
-
-    ASCIIColors.red("\n--- Demo Finished ---")
-
-if __name__ == "__main__":
-    main()