agent-cli 0.70.5__py3-none-any.whl

agent_cli/agents/memory/add.py

@@ -0,0 +1,190 @@
+"""Add memories directly to the memory store without LLM extraction."""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from datetime import UTC, datetime
+from pathlib import Path  # noqa: TC003
+from typing import TYPE_CHECKING, Any
+
+import typer
+
+from agent_cli import opts
+from agent_cli.agents.memory import memory_app
+from agent_cli.core.deps import requires_extras
+from agent_cli.core.utils import console, print_command_line_args
+
+if TYPE_CHECKING:
+    from agent_cli.memory._files import MemoryFileRecord
+
+# Matches markdown list prefixes: "- ", "* ", "+ ", "1. ", "2. ", etc.
+_LIST_PREFIX_RE = re.compile(r"^(?:[-*+]|\d+\.)\s+")
+
+
+def _strip_list_prefix(line: str) -> str:
+    """Strip markdown/text list prefixes from a line."""
+    return _LIST_PREFIX_RE.sub("", line)
+
+
+def _parse_json_items(
+    items: list[str | dict[str, Any]],
+    default_conversation_id: str,
+) -> list[tuple[str, str]]:
+    """Parse a JSON list of items into (content, conversation_id) tuples."""
+    results: list[tuple[str, str]] = []
+    for item in items:
+        if isinstance(item, str):
+            results.append((item, default_conversation_id))
+        else:
+            results.append((item["content"], item.get("conversation_id", default_conversation_id)))
+    return results
+
+
+def _parse_memories(
+    memories: list[str],
+    file: Path | None,
+    default_conversation_id: str,
+) -> list[tuple[str, str]]:
+    """Parse memories from arguments, file, or stdin."""
+    results: list[tuple[str, str]] = []
+
+    if file:
+        text = sys.stdin.read() if str(file) == "-" else file.read_text()
+        text = text.strip()
+
+        parsed_json = False
+        if text.startswith(("[", "{")):
+            try:
+                data = json.loads(text)
+                if isinstance(data, list):
+                    results.extend(_parse_json_items(data, default_conversation_id))
+                    parsed_json = True
+                elif isinstance(data, dict) and "memories" in data:
+                    results.extend(_parse_json_items(data["memories"], default_conversation_id))
+                    parsed_json = True
+            except json.JSONDecodeError:
+                pass  # Fall through to plain text parsing
+
+        if not parsed_json:
+            for line in text.splitlines():
+                stripped = line.strip()
+                if stripped:
+                    content = _strip_list_prefix(stripped)
+                    if content:
+                        results.append((content, default_conversation_id))
+
+    results.extend((m, default_conversation_id) for m in memories)
+    return results
+
+
+def _write_memories(
+    memory_path: Path,
+    memories: list[tuple[str, str]],
+    git_versioning: bool,
+) -> list[MemoryFileRecord]:
+    """Write memories to disk and optionally commit to git."""
+    import asyncio  # noqa: PLC0415
+
+    from agent_cli.memory._files import write_memory_file  # noqa: PLC0415
+    from agent_cli.memory._git import commit_changes, init_repo  # noqa: PLC0415
+
+    if git_versioning:
+        init_repo(memory_path)
+
+    records = []
+    for content, conversation_id in memories:
+        record = write_memory_file(
+            memory_path,
+            conversation_id=conversation_id,
+            role="memory",
+            created_at=datetime.now(tz=UTC).isoformat(),
+            content=content,
+        )
+        records.append(record)
+
+    if git_versioning and records:
+        asyncio.run(commit_changes(memory_path, f"Add {len(records)} memories directly"))
+
+    return records
+
+
+@memory_app.command("add")
+@requires_extras("memory")
+def add(
+    memories: list[str] = typer.Argument(  # noqa: B008
+        None,
+        help="Memories to add. Each argument becomes one fact.",
+    ),
+    file: Path | None = typer.Option(  # noqa: B008
+        None,
+        "--file",
+        "-f",
+        help="Read memories from file. Use '-' for stdin. Supports JSON array, JSON object with 'memories' key, or plain text (one per line).",
+    ),
+    conversation_id: str = typer.Option(
+        "default",
+        "--conversation-id",
+        "-c",
+        help="Conversation ID to add memories to.",
+    ),
+    memory_path: Path = typer.Option(  # noqa: B008
+        "./memory_db",
+        "--memory-path",
+        help="Path to the memory store.",
+    ),
+    git_versioning: bool = typer.Option(
+        True,  # noqa: FBT003
+        "--git-versioning/--no-git-versioning",
+        help="Commit changes to git.",
+    ),
+    quiet: bool = opts.QUIET,
+    config_file: str | None = opts.CONFIG_FILE,
+    print_args: bool = opts.PRINT_ARGS,
+) -> None:
+    """Add memories directly without LLM extraction.
+
+    This writes facts directly to the memory store, bypassing the LLM-based
+    fact extraction. Useful for bulk imports or seeding memories.
+
+    The memory proxy file watcher (if running) will auto-index new files.
+    Otherwise, they'll be indexed on next memory proxy startup.
+
+    Examples::
+
+        # Add single memories as arguments
+        agent-cli memory add "User likes coffee" "User lives in Amsterdam"
+
+        # Read from JSON file
+        agent-cli memory add -f memories.json
+
+        # Read from stdin (plain text, one per line)
+        echo "User prefers dark mode" | agent-cli memory add -f -
+
+        # Read JSON from stdin
+        echo '["Fact one", "Fact two"]' | agent-cli memory add -f -
+
+        # Specify conversation ID
+        agent-cli memory add -c work "Project deadline is Friday"
+
+    """
+    if print_args:
+        print_command_line_args(locals())
+
+    parsed = _parse_memories(memories or [], file, conversation_id)
+
+    if not parsed:
+        console.print("[red]No memories provided. Use arguments or --file.[/red]")
+        raise typer.Exit(1)
+
+    memory_path = memory_path.resolve()
+    records = _write_memories(memory_path, parsed, git_versioning)
+
+    if not quiet:
+        console.print(f"[green]Added {len(records)} memories to {memory_path}[/green]")
+        max_preview = 60
+        for record in records:
+            preview = record.content[:max_preview]
+            ellipsis = "..." if len(record.content) > max_preview else ""
+            console.print(f"  - [dim]{preview}{ellipsis}[/dim]")

agent_cli/agents/memory/proxy.py

@@ -0,0 +1,160 @@
+"""Memory Proxy agent command (long-term memory with Chroma)."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path  # noqa: TC003
+
+import typer
+from rich.logging import RichHandler
+
+from agent_cli import constants, opts
+from agent_cli.agents.memory import memory_app
+from agent_cli.core.deps import requires_extras
+from agent_cli.core.utils import console, print_command_line_args
+
+
+@memory_app.command("proxy")
+@requires_extras("memory")
+def proxy(
+    memory_path: Path = typer.Option(  # noqa: B008
+        "./memory_db",
+        help="Path to the memory store (files + derived vector index).",
+        rich_help_panel="Memory Configuration",
+    ),
+    openai_base_url: str | None = opts.OPENAI_BASE_URL,
+    embedding_model: str = opts.EMBEDDING_MODEL,
+    openai_api_key: str | None = opts.OPENAI_API_KEY,
+    default_top_k: int = typer.Option(
+        5,
+        help="Number of memory entries to retrieve per query.",
+        rich_help_panel="Memory Configuration",
+    ),
+    host: str = opts.SERVER_HOST,
+    port: int = typer.Option(
+        8100,
+        help="Port to bind to",
+        rich_help_panel="Server Configuration",
+    ),
+    max_entries: int = typer.Option(
+        500,
+        help="Maximum stored memory entries per conversation (excluding summary).",
+        rich_help_panel="Memory Configuration",
+    ),
+    mmr_lambda: float = typer.Option(
+        0.7,
+        help="MMR lambda (0-1): higher favors relevance, lower favors diversity.",
+        rich_help_panel="Memory Configuration",
+    ),
+    recency_weight: float = typer.Option(
+        0.2,
+        help="Recency score weight (0.0-1.0). Controls freshness vs. relevance. Default 0.2 (20% recency, 80% semantic relevance).",
+        rich_help_panel="Memory Configuration",
+    ),
+    score_threshold: float = typer.Option(
+        0.35,
+        help="Minimum semantic relevance threshold (0.0-1.0). Memories below this score are discarded to reduce noise.",
+        rich_help_panel="Memory Configuration",
+    ),
+    summarization: bool = typer.Option(
+        True,  # noqa: FBT003
+        "--summarization/--no-summarization",
+        help="Enable automatic fact extraction and summaries.",
+        rich_help_panel="Memory Configuration",
+    ),
+    git_versioning: bool = typer.Option(
+        True,  # noqa: FBT003
+        "--git-versioning/--no-git-versioning",
+        help="Enable automatic git commit of memory changes.",
+        rich_help_panel="Memory Configuration",
+    ),
+    log_level: opts.LogLevel = opts.LOG_LEVEL,
+    config_file: str | None = opts.CONFIG_FILE,
+    print_args: bool = opts.PRINT_ARGS,
+) -> None:
+    """Start the memory-backed chat proxy server.
+
+    This server acts as a middleware between your chat client (e.g., a web UI,
+    CLI, or IDE plugin) and an OpenAI-compatible LLM provider (e.g., OpenAI,
+    Ollama, vLLM).
+
+    Key Features:
+
+    - **Simple Markdown Files:** Memories are stored as human-readable Markdown
+      files, serving as the ultimate source of truth.
+    - **Automatic Version Control:** Built-in Git integration automatically
+      commits changes, providing a full history of memory evolution.
+    - **Lightweight & Local:** Minimal dependencies and runs entirely on your
+      machine.
+    - **Proxy Middleware:** Works transparently with any OpenAI-compatible
+      `/chat/completions` endpoint.
+
+    How it works:
+
+    1.  Intercepts `POST /v1/chat/completions` requests.
+    2.  **Retrieves** relevant memories (facts, previous conversations) from a
+        local vector database (ChromaDB) based on the user's query.
+    3.  **Injects** these memories into the system prompt.
+    4.  **Forwards** the augmented request to the real LLM (`--openai-base-url`).
+    5.  **Extracts** new facts from the conversation in the background and
+        updates the long-term memory store (including handling contradictions).
+
+    Use this to give "long-term memory" to any OpenAI-compatible application.
+    Point your client's base URL to `http://localhost:8100/v1`.
+    """
+    if print_args:
+        print_command_line_args(locals())
+
+    import uvicorn  # noqa: PLC0415
+
+    from agent_cli.memory._files import ensure_store_dirs  # noqa: PLC0415
+    from agent_cli.memory.api import create_app  # noqa: PLC0415
+
+    logging.basicConfig(
+        level=log_level.upper(),
+        format="%(message)s",
+        datefmt="[%X]",
+        handlers=[RichHandler(console=console, rich_tracebacks=True)],
+        force=True,
+    )
+
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("chromadb").setLevel(logging.WARNING)
+    logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+
+    memory_path = memory_path.resolve()
+    entries_dir, _ = ensure_store_dirs(memory_path)
+    if openai_base_url is None:
+        openai_base_url = constants.DEFAULT_OPENAI_BASE_URL
+
+    console.print(f"[bold green]Starting Memory Proxy on {host}:{port}[/bold green]")
+    console.print(f"  💾 Memory store: [blue]{memory_path}[/blue]")
+    console.print(f"  📁 Entries: [blue]{entries_dir}[/blue]")
+    console.print(f"  🤖 Backend: [blue]{openai_base_url}[/blue]")
+    console.print(f"  🧠 Embeddings: Using [blue]{embedding_model}[/blue]")
+    console.print(f"  🔍 Memory top_k: [blue]{default_top_k}[/blue] entries per query")
+    console.print(f"  🧹 Max entries per conversation: [blue]{max_entries}[/blue]")
+    console.print(
+        f"  ⚖️  Scoring: MMR λ=[blue]{mmr_lambda}[/blue], Recency w=[blue]{recency_weight}[/blue], Threshold=[blue]{score_threshold}[/blue]",
+    )
+    if not summarization:
+        console.print("  ⚙️  Summaries: [red]disabled[/red]")
+    if git_versioning:
+        console.print("  📝 Git Versioning: [green]enabled[/green]")
+
+    fastapi_app = create_app(
+        memory_path,
+        openai_base_url,
+        embedding_model=embedding_model,
+        embedding_api_key=openai_api_key,
+        chat_api_key=openai_api_key,
+        default_top_k=default_top_k,
+        enable_summarization=summarization,
+        max_entries=max_entries,
+        mmr_lambda=mmr_lambda,
+        recency_weight=recency_weight,
+        score_threshold=score_threshold,
+        enable_git_versioning=git_versioning,
+    )
+
+    uvicorn.run(fastapi_app, host=host, port=port, log_config=None)

agent_cli/agents/rag_proxy.py

@@ -0,0 +1,128 @@
+"""RAG Proxy agent command."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path  # noqa: TC003
+
+import typer
+from rich.logging import RichHandler
+
+from agent_cli import constants, opts
+from agent_cli.cli import app
+from agent_cli.core.deps import requires_extras
+from agent_cli.core.utils import (
+    console,
+    print_command_line_args,
+    print_error_message,
+)
+
+
+@app.command("rag-proxy", rich_help_panel="Servers")
+@requires_extras("rag")
+def rag_proxy(
+    docs_folder: Path = typer.Option(  # noqa: B008
+        "./rag_docs",
+        help="Folder to watch for documents",
+        rich_help_panel="RAG Configuration",
+    ),
+    chroma_path: Path = typer.Option(  # noqa: B008
+        "./rag_db",
+        help="Path to ChromaDB persistence directory",
+        rich_help_panel="RAG Configuration",
+    ),
+    openai_base_url: str | None = opts.OPENAI_BASE_URL,
+    embedding_model: str = opts.EMBEDDING_MODEL,
+    openai_api_key: str | None = opts.OPENAI_API_KEY,
+    limit: int = typer.Option(
+        3,
+        help="Number of document chunks to retrieve per query.",
+        rich_help_panel="RAG Configuration",
+    ),
+    host: str = opts.SERVER_HOST,
+    port: int = typer.Option(
+        8000,
+        help="Port to bind to",
+        rich_help_panel="Server Configuration",
+    ),
+    log_level: opts.LogLevel = opts.LOG_LEVEL,
+    config_file: str | None = opts.CONFIG_FILE,
+    print_args: bool = opts.PRINT_ARGS,
+    enable_rag_tools: bool = typer.Option(
+        True,  # noqa: FBT003
+        "--rag-tools/--no-rag-tools",
+        help="Allow agent to fetch full documents when snippets are insufficient.",
+        rich_help_panel="RAG Configuration",
+    ),
+) -> None:
+    """Start the RAG (Retrieval-Augmented Generation) Proxy Server.
+
+    This server watches a folder for documents, indexes them, and provides
+    an OpenAI-compatible API that proxies requests to a backend LLM (like llama.cpp),
+    injecting relevant context from the documents.
+    """
+    if print_args:
+        print_command_line_args(locals())
+    # Configure logging
+    logging.basicConfig(
+        level=log_level.upper(),
+        format="%(message)s",
+        datefmt="[%X]",
+        handlers=[RichHandler(console=console, rich_tracebacks=True)],
+        force=True,
+    )
+
+    # Suppress noisy logs from libraries
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+    logging.getLogger("chromadb").setLevel(logging.WARNING)
+    logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+
+    import uvicorn  # noqa: PLC0415
+
+    from agent_cli.rag.api import create_app  # noqa: PLC0415
+
+    docs_folder = docs_folder.resolve()
+    chroma_path = chroma_path.resolve()
+
+    # Validate paths don't overlap - mixing docs and DB causes corruption
+    if docs_folder == chroma_path:
+        print_error_message(
+            "docs-folder and chroma-path cannot be the same directory.\n"
+            "ChromaDB creates internal files that would be indexed as documents.",
+        )
+        raise typer.Exit(1)
+    if chroma_path in docs_folder.parents:
+        print_error_message(
+            f"docs-folder ({docs_folder}) is inside chroma-path ({chroma_path}).\n"
+            "ChromaDB creates internal files that would be indexed as documents.",
+        )
+        raise typer.Exit(1)
+    if docs_folder in chroma_path.parents:
+        print_error_message(
+            f"chroma-path ({chroma_path}) is inside docs-folder ({docs_folder}).\n"
+            "ChromaDB files may be accidentally deleted when managing documents.",
+        )
+        raise typer.Exit(1)
+
+    if openai_base_url is None:
+        openai_base_url = constants.DEFAULT_OPENAI_BASE_URL
+
+    console.print(f"[bold green]Starting RAG Proxy on {host}:{port}[/bold green]")
+    console.print(f"  📂 Docs: [blue]{docs_folder}[/blue]")
+    console.print(f"  💾 DB: [blue]{chroma_path}[/blue]")
+    console.print(f"  🤖 Backend: [blue]{openai_base_url}[/blue]")
+    console.print(f"  🧠 Embeddings: Using [blue]{embedding_model}[/blue]")
+    console.print(f"  🔍 Limit: [blue]{limit}[/blue] chunks per query")
+
+    fastapi_app = create_app(
+        docs_folder,
+        chroma_path,
+        openai_base_url,
+        embedding_model,
+        openai_api_key,
+        openai_api_key,
+        limit,
+        enable_rag_tools=enable_rag_tools,
+    )
+
+    uvicorn.run(fastapi_app, host=host, port=port, log_config=None)

agent_cli/agents/speak.py

@@ -0,0 +1,209 @@
+"""Wyoming TTS Client for converting text to speech."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from contextlib import suppress
+from pathlib import Path  # noqa: TC003
+
+import typer
+
+from agent_cli import config, opts
+from agent_cli.cli import app
+from agent_cli.core import process
+from agent_cli.core.audio import setup_devices
+from agent_cli.core.deps import requires_extras
+from agent_cli.core.utils import (
+    enable_json_mode,
+    get_clipboard_text,
+    maybe_live,
+    print_command_line_args,
+    print_input_panel,
+    setup_logging,
+    stop_or_status_or_toggle,
+)
+from agent_cli.services.tts import handle_tts_playback
+
+LOGGER = logging.getLogger()
+
+
+async def _async_main(
+    *,
+    general_cfg: config.General,
+    text: str | None,
+    provider_cfg: config.ProviderSelection,
+    audio_out_cfg: config.AudioOutput,
+    wyoming_tts_cfg: config.WyomingTTS,
+    openai_tts_cfg: config.OpenAITTS,
+    kokoro_tts_cfg: config.KokoroTTS,
+    gemini_tts_cfg: config.GeminiTTS | None = None,
+) -> str | None:
+    """Async entry point for the speak command."""
+    # We only use setup_devices for its output device handling
+    device_info = setup_devices(general_cfg, None, audio_out_cfg)
+    if device_info is None:
+        return None
+    _, _, output_device_index = device_info
+    audio_out_cfg.output_device_index = output_device_index
+
+    # Get text from argument or clipboard
+    if text is None:
+        text = get_clipboard_text(quiet=general_cfg.quiet)
+        if not text:
+            return None
+        if not general_cfg.quiet:
+            print_input_panel(text, title="📋 Text from Clipboard")
+    elif not general_cfg.quiet:
+        print_input_panel(text, title="📝 Text to Speak")
+
+    # Handle TTS playback and saving
+    with maybe_live(not general_cfg.quiet) as live:
+        await handle_tts_playback(
+            text=text,
+            provider_cfg=provider_cfg,
+            audio_output_cfg=audio_out_cfg,
+            wyoming_tts_cfg=wyoming_tts_cfg,
+            openai_tts_cfg=openai_tts_cfg,
+            kokoro_tts_cfg=kokoro_tts_cfg,
+            gemini_tts_cfg=gemini_tts_cfg,
+            save_file=general_cfg.save_file,
+            quiet=general_cfg.quiet,
+            logger=LOGGER,
+            play_audio=not general_cfg.save_file,  # Don't play if saving to file
+            status_message="🔊 Synthesizing speech...",
+            description="Audio",
+            live=live,
+        )
+
+    return text
+
+
+@app.command("speak", rich_help_panel="Text Commands")
+@requires_extras("audio")
+def speak(
+    *,
+    text: str | None = typer.Argument(
+        None,
+        help="Text to speak. Reads from clipboard if not provided.",
+        rich_help_panel="General Options",
+    ),
+    # --- Provider Selection ---
+    tts_provider: str = opts.TTS_PROVIDER,
+    # --- TTS Configuration ---
+    # General
+    output_device_index: int | None = opts.OUTPUT_DEVICE_INDEX,
+    output_device_name: str | None = opts.OUTPUT_DEVICE_NAME,
+    tts_speed: float = opts.TTS_SPEED,
+    # Wyoming (local service)
+    tts_wyoming_ip: str = opts.TTS_WYOMING_IP,
+    tts_wyoming_port: int = opts.TTS_WYOMING_PORT,
+    tts_wyoming_voice: str | None = opts.TTS_WYOMING_VOICE,
+    tts_wyoming_language: str | None = opts.TTS_WYOMING_LANGUAGE,
+    tts_wyoming_speaker: str | None = opts.TTS_WYOMING_SPEAKER,
+    # OpenAI
+    tts_openai_model: str = opts.TTS_OPENAI_MODEL,
+    tts_openai_voice: str = opts.TTS_OPENAI_VOICE,
+    tts_openai_base_url: str | None = opts.TTS_OPENAI_BASE_URL,
+    # Kokoro
+    tts_kokoro_model: str = opts.TTS_KOKORO_MODEL,
+    tts_kokoro_voice: str = opts.TTS_KOKORO_VOICE,
+    tts_kokoro_host: str = opts.TTS_KOKORO_HOST,
+    # Gemini
+    tts_gemini_model: str = opts.TTS_GEMINI_MODEL,
+    tts_gemini_voice: str = opts.TTS_GEMINI_VOICE,
+    gemini_api_key: str | None = opts.GEMINI_API_KEY,
+    # --- General Options ---
+    list_devices: bool = opts.LIST_DEVICES,
+    save_file: Path | None = opts.SAVE_FILE,
+    stop: bool = opts.STOP,
+    status: bool = opts.STATUS,
+    toggle: bool = opts.TOGGLE,
+    log_level: opts.LogLevel = opts.LOG_LEVEL,
+    log_file: str | None = opts.LOG_FILE,
+    quiet: bool = opts.QUIET,
+    json_output: bool = opts.JSON_OUTPUT,
+    config_file: str | None = opts.CONFIG_FILE,
+    print_args: bool = opts.PRINT_ARGS,
+) -> None:
+    """Convert text to speech using Wyoming or OpenAI-compatible TTS server."""
+    if print_args:
+        print_command_line_args(locals())
+
+    effective_quiet = quiet or json_output
+    if json_output:
+        enable_json_mode()
+
+    setup_logging(log_level, log_file, quiet=effective_quiet)
+    general_cfg = config.General(
+        log_level=log_level,
+        log_file=log_file,
+        quiet=effective_quiet,
+        list_devices=list_devices,
+        save_file=save_file,
+    )
+    process_name = "speak"
+    if stop_or_status_or_toggle(
+        process_name,
+        "speak process",
+        stop,
+        status,
+        toggle,
+        quiet=general_cfg.quiet,
+    ):
+        return
+
+    # Use context manager for PID file management
+    with process.pid_file_context(process_name), suppress(KeyboardInterrupt):
+        provider_cfg = config.ProviderSelection(
+            tts_provider=tts_provider,
+            asr_provider="wyoming",  # Not used
+            llm_provider="ollama",  # Not used
+        )
+        audio_out_cfg = config.AudioOutput(
+            output_device_index=output_device_index,
+            output_device_name=output_device_name,
+            tts_speed=tts_speed,
+            enable_tts=True,  # Implied for speak command
+        )
+        wyoming_tts_cfg = config.WyomingTTS(
+            tts_wyoming_ip=tts_wyoming_ip,
+            tts_wyoming_port=tts_wyoming_port,
+            tts_wyoming_voice=tts_wyoming_voice,
+            tts_wyoming_language=tts_wyoming_language,
+            tts_wyoming_speaker=tts_wyoming_speaker,
+        )
+        openai_tts_cfg = config.OpenAITTS(
+            tts_openai_model=tts_openai_model,
+            tts_openai_voice=tts_openai_voice,
+            tts_openai_base_url=tts_openai_base_url,
+        )
+        kokoro_tts_cfg = config.KokoroTTS(
+            tts_kokoro_model=tts_kokoro_model,
+            tts_kokoro_voice=tts_kokoro_voice,
+            tts_kokoro_host=tts_kokoro_host,
+        )
+        gemini_tts_cfg = config.GeminiTTS(
+            tts_gemini_model=tts_gemini_model,
+            tts_gemini_voice=tts_gemini_voice,
+            gemini_api_key=gemini_api_key,
+        )
+
+        spoken_text = asyncio.run(
+            _async_main(
+                general_cfg=general_cfg,
+                text=text,
+                provider_cfg=provider_cfg,
+                audio_out_cfg=audio_out_cfg,
+                wyoming_tts_cfg=wyoming_tts_cfg,
+                openai_tts_cfg=openai_tts_cfg,
+                kokoro_tts_cfg=kokoro_tts_cfg,
+                gemini_tts_cfg=gemini_tts_cfg,
+            ),
+        )
+        if json_output:
+            result = {"text": spoken_text}
+            if save_file:
+                result["file"] = str(save_file)
+            print(json.dumps(result))