kivi-cli 2.0.6__py3-none-any.whl

kiviai/services/providers/vllm.py

@@ -0,0 +1,319 @@
+"""vLLM provider — OpenAI-compatible API with agentic tool-calling loop."""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+from typing import AsyncIterator
+
+from .base import BaseProvider, ProviderConfig, ProviderEvent, EventType
+
+log = logging.getLogger(__name__)
+
+DEFAULT_VLLM_URL = "http://192.168.170.49:8000"
+DEFAULT_VLLM_MODEL = ""  # empty = vLLM auto-picks the loaded model
+MAX_TOOL_ITERATIONS = 1248  # safety limit for agentic loop
+
+
+class VLLMProvider(BaseProvider):
+    name = "vllm"
+    display_name = "vLLM (Local)"
+    description = "Self-hosted models via vLLM's OpenAI-compatible API. Run any HuggingFace model locally with GPU acceleration. Configure IP, port, and model in Settings."
+    supports_streaming = True
+    supports_tools = True
+    supports_sessions = False
+    available_models = ["auto"]
+
+    def __init__(self):
+        self._stop = False
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    async def _discover_model(self, base_url: str) -> str | None:
+        """Auto-discover model from server /v1/models endpoint."""
+        try:
+            import httpx
+            async with httpx.AsyncClient(timeout=5) as hc:
+                r = await hc.get(f"{base_url}/models")
+                data = r.json()
+                if data.get("data"):
+                    return data["data"][0]["id"]
+        except Exception:
+            pass
+        return None
+
+    @staticmethod
+    def _extract_thinking(content: str) -> tuple[str, str]:
+        """Separate thinking from visible content for Qwen3 and similar models.
+        
+        Handles multiple formats:
+        - <think>X</think>Y  → thinking=X, content=Y
+        - X</think>Y         → thinking=X, content=Y (Qwen3 tool-call format)
+        - <think>X (unclosed) → thinking=X, content=""
+        
+        Returns (thinking_text, clean_content).
+        """
+        if not content:
+            return "", ""
+        
+        # Case 1: Full <think>...</think> pairs
+        if '<think>' in content:
+            thinking_parts = re.findall(r'<think>(.*?)</think>', content, re.DOTALL)
+            clean = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL)
+            # Handle unclosed <think> at end
+            unclosed = re.search(r'<think>(.*?)$', clean, re.DOTALL)
+            if unclosed:
+                thinking_parts.append(unclosed.group(1))
+                clean = re.sub(r'<think>.*?$', '', clean, flags=re.DOTALL)
+            clean = clean.strip()
+            return "\n".join(thinking_parts).strip(), clean
+        
+        # Case 2: Bare </think> (Qwen3 pattern — thinking before tag, content after)
+        if '</think>' in content:
+            parts = content.split('</think>', 1)
+            thinking = parts[0].strip()
+            clean = parts[1].strip() if len(parts) > 1 else ""
+            return thinking, clean
+        
+        # Case 3: No thinking markers
+        return "", content.strip()
+
+    def _build_messages(self, prompt: str, history: list | None, cwd: str, images: list | None = None) -> list[dict]:
+        """Build the messages list with system prompt, history, and user prompt.
+        
+        If images is provided (list of base64 data-URLs), the user message uses
+        the OpenAI multimodal content format with image_url entries.
+        """
+        from kiviai.services.tools.tool_manager import get_system_prompt
+
+        messages = [{"role": "system", "content": get_system_prompt(cwd)}]
+        if history:
+            for h in history:
+                if h.get("role") in ("user", "assistant") and not h.get("metadata"):
+                    messages.append({"role": h["role"], "content": h["content"]})
+
+        # Build user message — multimodal if images present
+        if images:
+            content_parts = []
+            if prompt:
+                content_parts.append({"type": "text", "text": prompt})
+            for img_data in images:
+                content_parts.append({
+                    "type": "image_url",
+                    "image_url": {"url": img_data}
+                })
+            messages.append({"role": "user", "content": content_parts})
+        else:
+            messages.append({"role": "user", "content": prompt})
+        return messages
+
+    async def _execute_tool(self, name: str, arguments: dict, cwd: str) -> tuple[str, bool]:
+        """Run a tool in a thread pool to avoid blocking the event loop."""
+        from kiviai.services.tools.tool_manager import execute_tool
+        return await asyncio.get_event_loop().run_in_executor(
+            None, execute_tool, name, arguments, cwd
+        )
+
+    # ------------------------------------------------------------------
+    # Main run loop
+    # ------------------------------------------------------------------
+
+    async def run(self, prompt: str, config: ProviderConfig, history=None) -> AsyncIterator[ProviderEvent]:
+        """Agentic loop: stream text, detect tool calls, execute, repeat."""
+        self._stop = False
+        base_url = config.base_url or config.extra.get("vllm_url") or DEFAULT_VLLM_URL
+        api_key = config.api_key or config.extra.get("vllm_key") or "dummy"
+        model = config.model if config.model else (
+            config.extra.get("vllm_model") if config.extra.get("vllm_model") else DEFAULT_VLLM_MODEL
+        )
+        cwd = config.cwd or config.extra.get("cwd", "") or config.extra.get("working_dir", "")
+
+        if not base_url.endswith("/v1"):
+            base_url = base_url.rstrip("/") + "/v1"
+
+        if not model:
+            model = await self._discover_model(base_url)
+        if not model:
+            yield ProviderEvent(type=EventType.ERROR,
+                                content="No model specified and could not auto-detect from vLLM server")
+            return
+
+        try:
+            from openai import AsyncOpenAI
+        except ImportError:
+            yield ProviderEvent(type=EventType.ERROR,
+                                content="openai package required: pip install openai")
+            return
+
+        from kiviai.services.tools.tool_manager import TOOL_DEFINITIONS
+
+        client = AsyncOpenAI(base_url=base_url, api_key=api_key)
+        images = config.extra.get("images") if config.extra else None
+        messages = self._build_messages(prompt, history, cwd, images=images)
+
+        for iteration in range(MAX_TOOL_ITERATIONS):
+            if self._stop:
+                yield ProviderEvent(type=EventType.TEXT, content="⏹ *stopped*")
+                yield ProviderEvent(type=EventType.DONE)
+                return
+
+            try:
+                # Non-streaming call to detect tool_calls in the response
+                response = await client.chat.completions.create(
+                    model=model,
+                    messages=messages,
+                    tools=TOOL_DEFINITIONS,
+                    tool_choice="auto",
+                    max_tokens=4096,
+                )
+            except Exception as e:
+                err_str = str(e)
+                # If the server doesn't support tools, fall back to plain streaming
+                if "tool" in err_str.lower() or "function" in err_str.lower() or "400" in err_str:
+                    log.warning("vLLM server doesn't support tools, falling back to plain text: %s", err_str)
+                    async for ev in self._plain_stream(client, model, messages):
+                        yield ev
+                    return
+                yield ProviderEvent(type=EventType.ERROR, content=err_str)
+                return
+
+            choice = response.choices[0] if response.choices else None
+            if not choice:
+                yield ProviderEvent(type=EventType.ERROR, content="No response from model")
+                return
+
+            msg = choice.message
+
+            # Separate thinking from visible content
+            if msg.content:
+                thinking, clean = self._extract_thinking(msg.content)
+                if thinking:
+                    yield ProviderEvent(type=EventType.THINKING, content=thinking)
+                if clean:
+                    yield ProviderEvent(type=EventType.TEXT, content=clean)
+
+            # Check for tool calls
+            if not msg.tool_calls:
+                # No more tools — model is done
+                break
+
+            # Append the assistant message (with tool_calls) to messages
+            messages.append(msg.model_dump())
+
+            # Execute each tool call
+            for tc in msg.tool_calls:
+                if self._stop:
+                    yield ProviderEvent(type=EventType.TEXT, content="\n⏹ *stopped*")
+                    yield ProviderEvent(type=EventType.DONE)
+                    return
+
+                fn_name = tc.function.name
+                try:
+                    fn_args = json.loads(tc.function.arguments) if tc.function.arguments else {}
+                except json.JSONDecodeError:
+                    fn_args = {}
+
+                # Emit TOOL_START event for frontend
+                yield ProviderEvent(
+                    type=EventType.TOOL_START,
+                    metadata={
+                        "title": f"⚙ {fn_name}",
+                        "args": json.dumps(fn_args, indent=2),
+                    },
+                )
+
+                # Execute the tool
+                result_text, is_error = await self._execute_tool(fn_name, fn_args, cwd)
+
+                # Emit TOOL_RESULT event for frontend
+                yield ProviderEvent(
+                    type=EventType.TOOL_RESULT,
+                    content=result_text,
+                    metadata={"is_error": is_error},
+                )
+
+                # Append tool result to messages for the next iteration
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc.id,
+                    "content": result_text[:8000],  # truncate for context limits
+                })
+
+            # Usage info (self-hosted = $0 cost)
+            if response.usage:
+                yield ProviderEvent(
+                    type=EventType.COST,
+                    metadata={
+                        "total_cost_usd": 0.0,
+                        "usage": {
+                            "input_tokens": response.usage.prompt_tokens or 0,
+                            "output_tokens": response.usage.completion_tokens or 0,
+                        },
+                    },
+                )
+        else:
+            yield ProviderEvent(
+                type=EventType.TEXT,
+                content=f"\n\n⚠ Reached max tool iterations ({MAX_TOOL_ITERATIONS}). Stopping.",
+            )
+
+        yield ProviderEvent(type=EventType.DONE)
+
+    # ------------------------------------------------------------------
+    # Fallback: plain streaming (no tools)
+    # ------------------------------------------------------------------
+
+    async def _plain_stream(self, client, model: str, messages: list[dict]) -> AsyncIterator[ProviderEvent]:
+        """Simple streaming text completion — fallback when tools are unsupported."""
+        try:
+            stream = await client.chat.completions.create(
+                model=model,
+                messages=messages,
+                stream=True,
+                max_tokens=4096,
+            )
+            last_chunk = None
+            async for chunk in stream:
+                if self._stop:
+                    yield ProviderEvent(type=EventType.TEXT, content="⏹ *stopped*")
+                    yield ProviderEvent(type=EventType.DONE)
+                    return
+                last_chunk = chunk
+                delta = chunk.choices[0].delta if chunk.choices else None
+                if delta and delta.content:
+                    yield ProviderEvent(type=EventType.TEXT, content=delta.content)
+                if chunk.choices and chunk.choices[0].finish_reason:
+                    break
+
+            if last_chunk and hasattr(last_chunk, 'usage') and last_chunk.usage:
+                yield ProviderEvent(
+                    type=EventType.COST,
+                    metadata={
+                        "total_cost_usd": 0.0,
+                        "usage": {
+                            "input_tokens": last_chunk.usage.prompt_tokens or 0,
+                            "output_tokens": last_chunk.usage.completion_tokens or 0,
+                        },
+                    },
+                )
+        except Exception as e:
+            yield ProviderEvent(type=EventType.ERROR, content=str(e))
+            return
+
+        yield ProviderEvent(type=EventType.DONE)
+
+    async def stop(self):
+        self._stop = True
+
+    async def health_check(self):
+        base_url = DEFAULT_VLLM_URL
+        try:
+            import httpx
+            async with httpx.AsyncClient(timeout=3) as client:
+                r = await client.get(f"{base_url}/health")
+                return {"status": "ok" if r.status_code == 200 else "error", "provider": self.name}
+        except Exception:
+            return {"status": "unavailable", "provider": self.name}

kiviai/services/scheduler.py

@@ -0,0 +1,244 @@
+"""
+Scheduler service — cron jobs, delayed tasks, recurring jobs.
+
+Supports:
+- One-time delayed tasks (run prompt after N seconds)
+- Recurring cron-style tasks (e.g., "every day at 9am")
+- Task queuing with priority
+- Persistent scheduling (survives restarts via SQLite)
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import sqlite3
+import uuid
+from datetime import datetime, timedelta
+from typing import Callable, Any
+
+log = logging.getLogger("cc-ui.scheduler")
+
+
+class ScheduledJob:
+    def __init__(self, id: str, name: str, prompt: str, model: str = "claude",
+                 mode: str = "bypassPermissions", cwd: str = "",
+                 schedule: str = "", next_run: str = "",
+                 interval_seconds: int = 0, one_shot: bool = False,
+                 enabled: bool = True, last_run: str = "",
+                 last_status: str = "", created_at: str = ""):
+        self.id = id
+        self.name = name
+        self.prompt = prompt
+        self.model = model
+        self.mode = mode
+        self.cwd = cwd
+        self.schedule = schedule  # cron expression or human-readable
+        self.next_run = next_run
+        self.interval_seconds = interval_seconds
+        self.one_shot = one_shot
+        self.enabled = enabled
+        self.last_run = last_run
+        self.last_status = last_status
+        self.created_at = created_at or datetime.now().isoformat()
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id, "name": self.name, "prompt": self.prompt,
+            "model": self.model, "mode": self.mode, "cwd": self.cwd,
+            "schedule": self.schedule, "next_run": self.next_run,
+            "interval_seconds": self.interval_seconds, "one_shot": self.one_shot,
+            "enabled": self.enabled, "last_run": self.last_run,
+            "last_status": self.last_status, "created_at": self.created_at,
+        }
+
+
+class Scheduler:
+    def __init__(self, db_path: str, task_callback: Callable = None):
+        self.db_path = db_path
+        self.task_callback = task_callback  # async fn(prompt, model, mode, cwd) -> task_id
+        self._jobs: dict[str, ScheduledJob] = {}
+        self._running = False
+        self._task: asyncio.Task | None = None
+        self._init_db()
+        self._load_jobs()
+
+    def _db(self):
+        return sqlite3.connect(self.db_path)
+
+    def _init_db(self):
+        with self._db() as con:
+            con.execute("""CREATE TABLE IF NOT EXISTS scheduled_jobs (
+                id TEXT PRIMARY KEY,
+                name TEXT, prompt TEXT, model TEXT, mode TEXT, cwd TEXT,
+                schedule TEXT, next_run TEXT, interval_seconds INTEGER,
+                one_shot INTEGER, enabled INTEGER,
+                last_run TEXT, last_status TEXT, created_at TEXT
+            )""")
+
+    def _load_jobs(self):
+        with self._db() as con:
+            rows = con.execute("SELECT * FROM scheduled_jobs").fetchall()
+        for r in rows:
+            job = ScheduledJob(
+                id=r[0], name=r[1], prompt=r[2], model=r[3], mode=r[4],
+                cwd=r[5], schedule=r[6], next_run=r[7],
+                interval_seconds=r[8], one_shot=bool(r[9]),
+                enabled=bool(r[10]), last_run=r[11], last_status=r[12],
+                created_at=r[13],
+            )
+            self._jobs[job.id] = job
+
+    def _save_job(self, job: ScheduledJob):
+        with self._db() as con:
+            con.execute("""INSERT OR REPLACE INTO scheduled_jobs
+                (id, name, prompt, model, mode, cwd, schedule, next_run,
+                 interval_seconds, one_shot, enabled, last_run, last_status, created_at)
+                VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+                (job.id, job.name, job.prompt, job.model, job.mode, job.cwd,
+                 job.schedule, job.next_run, job.interval_seconds,
+                 int(job.one_shot), int(job.enabled),
+                 job.last_run, job.last_status, job.created_at))
+
+    def _delete_job(self, job_id: str):
+        with self._db() as con:
+            con.execute("DELETE FROM scheduled_jobs WHERE id=?", (job_id,))
+        self._jobs.pop(job_id, None)
+
+    def add_job(self, name: str, prompt: str, model: str = "claude",
+                mode: str = "bypassPermissions", cwd: str = "",
+                schedule: str = "", interval_seconds: int = 0,
+                delay_seconds: int = 0, one_shot: bool = False) -> ScheduledJob:
+        """Add a new scheduled job."""
+        job_id = str(uuid.uuid4())[:8]
+
+        if delay_seconds > 0:
+            next_run = (datetime.now() + timedelta(seconds=delay_seconds)).isoformat()
+            one_shot = True
+        elif interval_seconds > 0:
+            next_run = (datetime.now() + timedelta(seconds=interval_seconds)).isoformat()
+        else:
+            next_run = self._parse_schedule(schedule)
+
+        job = ScheduledJob(
+            id=job_id, name=name, prompt=prompt, model=model, mode=mode,
+            cwd=cwd, schedule=schedule, next_run=next_run,
+            interval_seconds=interval_seconds, one_shot=one_shot,
+        )
+        self._jobs[job_id] = job
+        self._save_job(job)
+        log.info("Scheduled job '%s' (id=%s) next_run=%s", name, job_id, next_run)
+        return job
+
+    def remove_job(self, job_id: str) -> bool:
+        if job_id in self._jobs:
+            self._delete_job(job_id)
+            return True
+        return False
+
+    def list_jobs(self) -> list[dict]:
+        return [j.to_dict() for j in self._jobs.values()]
+
+    def get_job(self, job_id: str) -> dict | None:
+        job = self._jobs.get(job_id)
+        return job.to_dict() if job else None
+
+    def toggle_job(self, job_id: str) -> bool:
+        job = self._jobs.get(job_id)
+        if job:
+            job.enabled = not job.enabled
+            self._save_job(job)
+            return True
+        return False
+
+    def _parse_schedule(self, schedule: str) -> str:
+        """Parse a simple schedule string into next_run ISO timestamp."""
+        lower = schedule.lower().strip()
+        now = datetime.now()
+
+        if "every" in lower:
+            if "minute" in lower:
+                return (now + timedelta(minutes=1)).isoformat()
+            elif "hour" in lower:
+                return (now + timedelta(hours=1)).isoformat()
+            elif "day" in lower:
+                return (now + timedelta(days=1)).isoformat()
+            elif "week" in lower:
+                return (now + timedelta(weeks=1)).isoformat()
+
+        # Default: 1 hour from now
+        return (now + timedelta(hours=1)).isoformat()
+
+    def _compute_next_run(self, job: ScheduledJob) -> str:
+        """Compute next run time after execution."""
+        now = datetime.now()
+        if job.interval_seconds > 0:
+            return (now + timedelta(seconds=job.interval_seconds)).isoformat()
+        return self._parse_schedule(job.schedule)
+
+    async def start(self):
+        """Start the scheduler loop."""
+        if self._running:
+            return
+        self._running = True
+        self._task = asyncio.create_task(self._loop())
+        log.info("Scheduler started with %d jobs", len(self._jobs))
+
+    async def stop(self):
+        """Stop the scheduler loop."""
+        self._running = False
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+
+    async def _loop(self):
+        """Main scheduler loop — checks every 10 seconds."""
+        while self._running:
+            try:
+                now = datetime.now()
+                for job in list(self._jobs.values()):
+                    if not job.enabled or not job.next_run:
+                        continue
+                    try:
+                        next_run = datetime.fromisoformat(job.next_run)
+                    except ValueError:
+                        continue
+
+                    if now >= next_run:
+                        log.info("Executing scheduled job '%s' (id=%s)", job.name, job.id)
+                        await self._execute_job(job)
+
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                log.error("Scheduler loop error: %s", e)
+
+            await asyncio.sleep(10)
+
+    async def _execute_job(self, job: ScheduledJob):
+        """Execute a scheduled job."""
+        try:
+            if self.task_callback:
+                await self.task_callback(job.prompt, job.model, job.mode, job.cwd)
+                job.last_status = "success"
+            else:
+                job.last_status = "no_callback"
+
+            job.last_run = datetime.now().isoformat()
+
+            if job.one_shot:
+                job.enabled = False
+            else:
+                job.next_run = self._compute_next_run(job)
+
+            self._save_job(job)
+
+        except Exception as e:
+            job.last_status = f"error: {e}"
+            job.last_run = datetime.now().isoformat()
+            self._save_job(job)
+            log.error("Job '%s' failed: %s", job.name, e)

kiviai/services/tools/__init__.py

@@ -0,0 +1 @@
+"""Tools package — tool schemas + executor for local LLM providers."""

kiviai/services/tools/copilot_tools/__init__.py

@@ -0,0 +1,92 @@
+"""
+copilot_tools — Python implementations of GitHub Copilot CLI tools.
+
+Modules:
+    bash_execution      — Shell session management (bash, write_bash, read_bash, stop_bash, list_bash)
+    file_operations     — File I/O primitives (view, create, edit)
+    code_search         — Code & file discovery (grep, glob)
+    session_workflow    — Session state & user interaction (report_intent, ask_user, sql, fetch_docs)
+    agent_orchestration — Multi-agent orchestration (task, read_agent, list_agents, skill)
+    markdown            — Structured extraction from markdown documents
+    web                 — Web search, fetch, and ChromaDB-backed content store
+"""
+
+from copilot_tools.bash_execution import (
+    bash,
+    write_bash,
+    read_bash,
+    stop_bash,
+    list_bash,
+)
+from copilot_tools.file_operations import view, create, edit
+from copilot_tools.code_search import grep, glob_search
+from copilot_tools.session_workflow import (
+    report_intent,
+    ask_user,
+    sql,
+    fetch_copilot_cli_documentation,
+)
+from copilot_tools.agent_orchestration import (
+    launch_task,
+    read_agent,
+    list_agents,
+    execute_skill,
+)
+from copilot_tools.markdown import (
+    get_overview as markdown_get_overview,
+    get_headers as markdown_get_headers,
+    get_section as markdown_get_section,
+    get_intro as markdown_get_intro,
+    get_links as markdown_get_links,
+    get_tables_metadata as markdown_get_tables_metadata,
+    get_table as markdown_get_table,
+)
+from copilot_tools.web import (
+    web_fetch,
+    web_search,
+    web_store_get,
+    web_store_get_text,
+    web_store_search,
+    web_store_list,
+)
+
+__all__ = [
+    # bash_execution
+    "bash",
+    "write_bash",
+    "read_bash",
+    "stop_bash",
+    "list_bash",
+    # file_operations
+    "view",
+    "create",
+    "edit",
+    # code_search
+    "grep",
+    "glob_search",
+    # session_workflow
+    "report_intent",
+    "ask_user",
+    "sql",
+    "fetch_copilot_cli_documentation",
+    # agent_orchestration
+    "launch_task",
+    "read_agent",
+    "list_agents",
+    "execute_skill",
+    # markdown
+    "markdown_get_overview",
+    "markdown_get_headers",
+    "markdown_get_section",
+    "markdown_get_intro",
+    "markdown_get_links",
+    "markdown_get_tables_metadata",
+    "markdown_get_table",
+    # web
+    "web_search",
+    "web_fetch",
+    "web_store_get",
+    "web_store_get_text",
+    "web_store_search",
+    "web_store_list",
+]

kiviai/services/tools/copilot_tools/agent_orchestration/__init__.py

@@ -0,0 +1,17 @@
+"""
+Agent Orchestration Tools — multi-agent management.
+
+    launch_task   — Spawn a specialised sub-agent (explore, task, general-purpose, code-review)
+    read_agent    — Retrieve status & results from a background agent
+    list_agents   — List all active / completed agents
+    execute_skill — Execute a named skill in the main conversation context
+"""
+
+from copilot_tools.agent_orchestration.tools import (
+    launch_task,
+    read_agent,
+    list_agents,
+    execute_skill,
+)
+
+__all__ = ["launch_task", "read_agent", "list_agents", "execute_skill"]