kivi-cli 2.0.6__py3-none-any.whl

kiviai/services/providers/copilot.py

@@ -0,0 +1,251 @@
+"""GitHub Copilot provider — uses the official copilot-sdk Python package.
+
+Supports streaming, tool use, sessions, and multiple models
+(gpt-5.4, gpt-5-mini, claude-sonnet-4.6, claude-haiku-4.5, claude-opus-4.6).
+
+Requires: pip install github-copilot-sdk
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import sys
+from typing import AsyncIterator
+
+from .base import BaseProvider, ProviderConfig, ProviderEvent, EventType
+
+log = logging.getLogger("cc-ui.copilot")
+
+# Default model when none specified
+DEFAULT_MODEL = "gpt-5.4"
+
+
+class CopilotProvider(BaseProvider):
+    name = "copilot"
+    display_name = "GitHub Copilot"
+    description = "GitHub Copilot SDK with full agentic capabilities. Streaming, tool use, sessions, and multi-model support (GPT-5.4, GPT-5 mini, Claude Sonnet/Haiku/Opus). Runs the bundled Copilot CLI under the hood."
+    supports_streaming = True
+    supports_tools = True
+    supports_sessions = True
+    supports_agents = True
+    available_models = [
+        "gpt-5.4", "gpt-5-mini", "gpt-4.1", "gpt-4.1-mini",
+        "claude-sonnet-4.6", "claude-haiku-4.5", "claude-opus-4.6",
+        "o3-mini", "o4-mini",
+    ]
+
+    def __init__(self):
+        self._stop = False
+        self._client = None
+        self._session = None
+
+    async def run(self, prompt: str, config: ProviderConfig, history=None) -> AsyncIterator[ProviderEvent]:
+        # Lazy import — only fail when actually used
+        try:
+            # Ensure the SDK path is importable
+            sdk_path = None
+            try:
+                import copilot as _cp
+            except ImportError:
+                import glob
+                paths = glob.glob("/home/ntlpt24/.local/lib/python*/site-packages")
+                for p in paths:
+                    if p not in sys.path:
+                        sys.path.insert(0, p)
+                        sdk_path = p
+
+            from copilot import CopilotClient
+            from copilot.session import PermissionHandler
+            from copilot.generated.session_events import SessionEventType
+        except ImportError as e:
+            yield ProviderEvent(
+                type=EventType.ERROR,
+                content=f"Copilot SDK not installed: {e}\nInstall with: pip install github-copilot-sdk",
+            )
+            return
+
+        self._stop = False
+        model = config.model or config.extra.get("copilot_model") or DEFAULT_MODEL
+        session_id = config.session_id
+        text_buf = ""
+        total_cost = 0.0
+        usage = {}
+        resolved_session_id = None
+        total_input_tokens = 0
+        total_output_tokens = 0
+
+        try:
+            self._client = CopilotClient()
+            await self._client.start()
+
+            # Create or resume session
+            session_kwargs = dict(
+                on_permission_request=PermissionHandler.approve_all,
+                model=model,
+                streaming=True,
+            )
+
+            if session_id:
+                self._session = await self._client.resume_session(
+                    session_id,
+                    on_permission_request=PermissionHandler.approve_all,
+                )
+            else:
+                self._session = await self._client.create_session(**session_kwargs)
+
+            resolved_session_id = getattr(self._session, 'session_id', None) or session_id
+
+            # Collect events via callback
+            done_event = asyncio.Event()
+            events_queue: asyncio.Queue = asyncio.Queue()
+
+            def on_event(event):
+                events_queue.put_nowait(event)
+                etype = getattr(event, 'type', None)
+                if etype and etype.value in ('session.idle', 'session.error', 'session.shutdown'):
+                    done_event.set()
+
+            self._session.on(on_event)
+            await self._session.send(prompt)
+
+            # Process events until done
+            while not done_event.is_set() or not events_queue.empty():
+                if self._stop:
+                    yield ProviderEvent(type=EventType.TEXT, content="⏹ *stopped*")
+                    break
+
+                try:
+                    event = await asyncio.wait_for(events_queue.get(), timeout=1.0)
+                except asyncio.TimeoutError:
+                    continue
+
+                etype = getattr(event, 'type', None)
+                if not etype:
+                    continue
+
+                ev_type = etype.value
+                data = getattr(event, 'data', None)
+
+                if ev_type == 'assistant.message_delta' and data:
+                    delta = getattr(data, 'delta_content', '') or ''
+                    if delta:
+                        text_buf += delta
+                        yield ProviderEvent(type=EventType.TEXT, content=delta)
+
+                elif ev_type == 'assistant.reasoning_delta' and data:
+                    delta = getattr(data, 'delta_content', '') or ''
+                    if delta:
+                        yield ProviderEvent(type=EventType.THINKING, content=delta)
+
+                elif ev_type == 'tool.execution_start' and data:
+                    tool_name = getattr(data, 'tool_name', '') or 'tool'
+                    args = getattr(data, 'input', '') or ''
+                    yield ProviderEvent(
+                        type=EventType.TOOL_START,
+                        metadata={"title": f"⚙ {tool_name}", "args": str(args)[:500]},
+                    )
+
+                elif ev_type == 'tool.execution_complete' and data:
+                    output = getattr(data, 'output', '') or ''
+                    is_error = getattr(data, 'is_error', False)
+                    yield ProviderEvent(
+                        type=EventType.TOOL_RESULT,
+                        content=str(output)[:600],
+                        metadata={"is_error": bool(is_error)},
+                    )
+
+                elif ev_type == 'assistant.usage' and data:
+                    u = getattr(data, 'usage', None)
+                    if u:
+                        it = getattr(u, 'input_tokens', 0) or 0
+                        ot = getattr(u, 'output_tokens', 0) or 0
+                        total_input_tokens += it
+                        total_output_tokens += ot
+                        usage["input_tokens"] = total_input_tokens
+                        usage["output_tokens"] = total_output_tokens
+
+                elif ev_type == 'subagent.started' and data:
+                    agent_id = getattr(data, 'session_id', '') or ''
+                    label = getattr(data, 'label', '') or f'Sub-agent {agent_id[:8]}'
+                    yield ProviderEvent(
+                        type=EventType.AGENT_GROUP,
+                        metadata={"agent_id": agent_id, "agent_label": label, "status": "running", "children": []},
+                    )
+
+                elif ev_type == 'subagent.completed' and data:
+                    agent_id = getattr(data, 'session_id', '') or ''
+                    yield ProviderEvent(
+                        type=EventType.AGENT_GROUP,
+                        metadata={"agent_id": agent_id, "status": "done"},
+                    )
+
+                elif ev_type == 'session.error' and data:
+                    msg = getattr(data, 'message', '') or str(data)
+                    yield ProviderEvent(type=EventType.ERROR, content=f"Copilot error: {msg}")
+                    break
+
+                elif ev_type == 'session.idle':
+                    break
+
+        except Exception as e:
+            log.exception("Copilot provider error: %s", e)
+            yield ProviderEvent(type=EventType.ERROR, content=str(e))
+        finally:
+            # Cleanup
+            try:
+                if self._session:
+                    await self._session.disconnect()
+                if self._client:
+                    await self._client.stop()
+            except Exception:
+                pass
+            self._session = None
+            self._client = None
+
+        # Emit cost/session info with calculated cost
+        from .model_costs import estimate_cost
+        if total_input_tokens or total_output_tokens:
+            total_cost = estimate_cost(
+                model,
+                input_tokens=total_input_tokens,
+                output_tokens=total_output_tokens,
+            )
+        if resolved_session_id or usage:
+            yield ProviderEvent(
+                type=EventType.COST,
+                metadata={
+                    "session_id": resolved_session_id,
+                    "total_cost_usd": total_cost,
+                    "usage": usage,
+                },
+            )
+
+        yield ProviderEvent(type=EventType.DONE)
+
+    async def stop(self):
+        self._stop = True
+        if self._session:
+            try:
+                await self._session.disconnect()
+            except Exception:
+                pass
+
+    async def health_check(self):
+        try:
+            sdk_ok = False
+            try:
+                import copilot
+                sdk_ok = True
+            except ImportError:
+                import sys, glob
+                for p in glob.glob("/home/ntlpt24/.local/lib/python*/site-packages"):
+                    if p not in sys.path:
+                        sys.path.insert(0, p)
+                from copilot import CopilotClient
+                sdk_ok = True
+
+            if sdk_ok:
+                return {"status": "ok", "provider": self.name, "sdk": "github-copilot-sdk"}
+        except Exception as e:
+            return {"status": "unavailable", "provider": self.name, "error": str(e)}
+        return {"status": "unavailable", "provider": self.name}

kiviai/services/providers/inhouse.py

@@ -0,0 +1,130 @@
+"""In-house AI framework provider — wraps lib/ai.py AIAgent."""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import sys
+from typing import AsyncIterator
+
+from .base import BaseProvider, ProviderConfig, ProviderEvent, EventType
+
+
+class InhouseProvider(BaseProvider):
+    name = "inhouse"
+    display_name = "AI Framework (In-house)"
+    description = "Custom AI framework from lab/src/ai. Unified interface for multiple backends (OpenAI, Anthropic, local). Supports tool calling, structured output, and batch processing."
+    supports_streaming = True
+    supports_tools = True
+    supports_sessions = False
+    available_models = ["auto"]
+
+    def __init__(self):
+        self._stop = False
+
+    async def run(self, prompt: str, config: ProviderConfig, history=None) -> AsyncIterator[ProviderEvent]:
+        self._stop = False
+
+        base_url = config.base_url or config.extra.get("base_url") or os.environ.get("OPENAI_BASE_URL", "http://localhost:9999/v1")
+        api_key = config.api_key or config.extra.get("api_key") or "dummy"
+        model = config.model or config.extra.get("model") or ""
+        mode = config.extra.get("ai_mode") or "instruct_general"
+        use_tools = config.extra.get("use_tools", False)
+
+        try:
+            # Import from our lib
+            here = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+            lib_path = os.path.join(here, "lib")
+            if lib_path not in sys.path:
+                sys.path.insert(0, lib_path)
+
+            from ai import AIAgent, AIConfig, Chat, Text, ToolCall, ToolResult, StepResult, AgentResult, DoneEvent
+            from ai import read_file, write_file, edit_file, bash_run, glob_files, grep_files
+
+            ai_config = AIConfig(base_url=base_url, api_key=api_key)
+            tools = None
+            if use_tools:
+                tools = [read_file, write_file, edit_file, bash_run, glob_files, grep_files]
+            agent = AIAgent(config=ai_config, tools=tools)
+
+            # Build chat with history
+            messages = []
+            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"]})
+            messages.append({"role": "user", "content": prompt})
+
+            chat = Chat.__new__(Chat)
+            chat._messages = messages
+
+            # Run in thread to avoid blocking
+            def _run_sync():
+                events = []
+                if use_tools:
+                    for event in agent.forward(chat, model=model, mode=mode):
+                        events.append(event)
+                else:
+                    for event in agent.step(chat, model=model, mode=mode):
+                        events.append(event)
+                return events
+
+            events = await asyncio.to_thread(_run_sync)
+
+            for event in events:
+                if self._stop:
+                    yield ProviderEvent(type=EventType.TEXT, content="⏹ *stopped*")
+                    yield ProviderEvent(type=EventType.DONE)
+                    return
+
+                if isinstance(event, Text):
+                    yield ProviderEvent(type=EventType.TEXT, content=event.content)
+                elif isinstance(event, ToolCall):
+                    yield ProviderEvent(
+                        type=EventType.TOOL_START,
+                        metadata={"title": f"⚙ {event.name}", "args": event.arguments},
+                    )
+                elif isinstance(event, ToolResult):
+                    yield ProviderEvent(
+                        type=EventType.TOOL_RESULT,
+                        content=event.result[:600],
+                        metadata={"is_error": False},
+                    )
+                elif isinstance(event, StepResult):
+                    from .model_costs import estimate_cost
+                    it = event.input_tokens or 0
+                    ot = event.output_tokens or 0
+                    step_cost = estimate_cost(
+                        model or "auto",
+                        input_tokens=it,
+                        output_tokens=ot,
+                    )
+                    yield ProviderEvent(
+                        type=EventType.COST,
+                        metadata={
+                            "total_cost_usd": step_cost,
+                            "usage": {
+                                "input_tokens": it,
+                                "output_tokens": ot,
+                            },
+                        },
+                    )
+
+        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):
+        try:
+            here = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+            lib_path = os.path.join(here, "lib")
+            if os.path.exists(os.path.join(lib_path, "ai.py")):
+                return {"status": "ok", "provider": self.name}
+            return {"status": "missing_lib", "provider": self.name}
+        except Exception:
+            return {"status": "error", "provider": self.name}

kiviai/services/providers/kivi.py

@@ -0,0 +1,108 @@
+"""Kivi provider — local model via OpenAI-compatible API (same as vLLM but separate config)."""
+from __future__ import annotations
+
+import asyncio
+from typing import AsyncIterator
+
+from .base import BaseProvider, ProviderConfig, ProviderEvent, EventType
+
+DEFAULT_KIVI_URL = "http://localhost:9999"
+DEFAULT_KIVI_MODEL = "mock-model-v1"
+
+
+class KiviProvider(BaseProvider):
+    name = "kivi"
+    display_name = "Kivi (Local)"
+    description = "Lightweight local inference via OpenAI-compatible API. Similar to vLLM but for smaller models. Supports streaming and tool-use formatted responses."
+    supports_streaming = True
+    supports_tools = True
+    supports_sessions = False
+    available_models = ["auto"]
+
+    def __init__(self):
+        self._stop = False
+
+    async def run(self, prompt: str, config: ProviderConfig, history=None) -> AsyncIterator[ProviderEvent]:
+        self._stop = False
+        base_url = config.base_url or config.extra.get("kivi_url") or DEFAULT_KIVI_URL
+        api_key = config.api_key or config.extra.get("kivi_key") or "dummy"
+        model = config.model or config.extra.get("kivi_model") or DEFAULT_KIVI_MODEL
+
+        if not base_url.endswith("/v1"):
+            base_url = base_url.rstrip("/") + "/v1"
+
+        messages = []
+        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"]})
+        messages.append({"role": "user", "content": prompt})
+
+        try:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(base_url=base_url, api_key=api_key)
+
+            tools = None
+            if config.extra.get("tools"):
+                tools = config.extra["tools"]
+
+            kwargs = {
+                "model": model,
+                "messages": messages,
+                "stream": True,
+                "max_tokens": 4096,
+            }
+            if tools:
+                kwargs["tools"] = tools
+
+            stream = await client.chat.completions.create(**kwargs)
+
+            async for chunk in stream:
+                if self._stop:
+                    yield ProviderEvent(type=EventType.TEXT, content="⏹ *stopped*")
+                    yield ProviderEvent(type=EventType.DONE)
+                    return
+
+                delta = chunk.choices[0].delta if chunk.choices else None
+                if delta:
+                    if delta.content:
+                        yield ProviderEvent(type=EventType.TEXT, content=delta.content)
+                    if delta.tool_calls:
+                        for tc in delta.tool_calls:
+                            if tc.function and tc.function.name:
+                                yield ProviderEvent(
+                                    type=EventType.TOOL_START,
+                                    metadata={"title": f"⚙ {tc.function.name}", "args": tc.function.arguments or ""},
+                                )
+
+                if chunk.choices and chunk.choices[0].finish_reason:
+                    break
+
+            # Emit cost event (self-hosted = $0)
+            yield ProviderEvent(
+                type=EventType.COST,
+                metadata={"total_cost_usd": 0.0, "usage": {}},
+            )
+
+        except ImportError:
+            yield ProviderEvent(type=EventType.ERROR, content="openai package required: pip install openai")
+            return
+        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_KIVI_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/providers/model_costs.py

@@ -0,0 +1,137 @@
+"""
+Centralized per-token pricing for all supported models.
+
+All costs are in USD per million tokens.
+Input  = cost to process the prompt/context
+Output = cost to generate the response
+
+Usage:
+    from model_costs import COSTS, estimate_cost
+    cost = estimate_cost("anthropic/claude-haiku-4.5-20241022", input_tokens=1000, output_tokens=500)
+    # => 0.0015  ($0.001 input + $0.0025 output)
+"""
+
+# ── Pricing: $ per 1,000,000 tokens ──────────────────────────────
+
+COSTS: dict[str, tuple[float, float]] = {
+    # ── Anthropic ────────────────────────────────────────────────
+    # Model                                         (input, output)
+    "claude-haiku-4.5":                (1.00,  5.00),  # Claude 4.5 Haiku / 3.5 Haiku
+    "claude-haiku-4-5":                (1.00,  5.00),
+    "claude-haiku-3.5":                (1.00,  5.00),
+    "claude-sonnet-4":                 (3.00, 15.00),  # Claude 4 Sonnet
+    "claude-sonnet-4-20250514":        (3.00, 15.00),
+    "claude-sonnet-4-20250514:20250514": (3.00, 15.00),
+    "claude-sonnet-4-20250514-thinking": (3.00, 15.00),
+    "claude-sonnet-4-6":               (3.00, 15.00),
+    "claude-sonnet-4-20250514-6":      (3.00, 15.00),
+    "claude-sonnet-4.5":               (3.00, 15.00),
+    "claude-sonnet-4-5":               (3.00, 15.00),
+    "claude-sonnet-4-20250514-5":      (3.00, 15.00),
+    "claude-sonnet-4-20250514-6":      (3.00, 15.00),
+    "claude-opus-4":                   (15.00, 75.00),  # Claude 4 Opus
+    "claude-opus-4-20250514":          (15.00, 75.00),
+    "claude-opus-4-6":                 (15.00, 75.00),
+    "claude-opus-4-20250514-6":        (15.00, 75.00),
+    "sonnet":                          (3.00, 15.00),   # Claude short names
+    "opus":                            (15.00, 75.00),
+    "haiku":                           (1.00,  5.00),
+
+    # ── OpenAI ──────────────────────────────────────────────────
+    # Model                                         (input, output)
+    "gpt-5.4":                         (1.25, 10.50),  # GPT-5.4 (latest flagship)
+    "gpt-5.4-mini":                    (0.75,  4.50),  # GPT-5.4 Mini
+    "gpt-5-mini":                      (0.25,  2.00),  # GPT-5 Mini (budget)
+    "gpt-4.1":                         (2.00,  8.00),  # GPT-4.1
+    "gpt-4.1-mini":                    (0.40,  1.60),  # GPT-4.1 Mini
+    "gpt-4.1-nano":                    (0.10,  0.40),  # GPT-4.1 Nano (cheapest GPT)
+    "gpt-4o":                          (2.50, 10.00),  # GPT-4o
+    "gpt-4o-mini":                     (0.15,  0.60),  # GPT-4o Mini
+    "o3":                              (10.50, 42.00),  # O3 (reasoning)
+    "o3-mini":                         (1.10,  4.40),  # O3 Mini
+    "o4-mini":                         (1.10,  4.40),  # O4 Mini
+
+    # ── OpenCode model aliases (full paths) ─────────────────────
+    "anthropic/claude-sonnet-4-20250514":     (3.00, 15.00),
+    "anthropic/claude-opus-4-20250514":       (15.00, 75.00),
+    "anthropic/claude-haiku-4.5-20241022":    (1.00,  5.00),
+    "openai/gpt-4.1":                        (2.00,  8.00),
+    "openai/gpt-4.1-mini":                   (0.40,  1.60),
+    "openai/o3":                             (10.50, 42.00),
+    "openai/o4-mini":                        (1.10,  4.40),
+}
+
+
+def estimate_cost(
+    model: str,
+    input_tokens: int = 0,
+    output_tokens: int = 0,
+    cache_read_tokens: int = 0,
+    cache_write_tokens: int = 0,
+    reasoning_tokens: int = 0,
+) -> float:
+    """
+    Estimate cost in USD for a given model and token usage.
+
+    Cache pricing (Anthropic):
+      - cache_write (creation): 1.25x normal input rate
+      - cache_read: 0.1x normal input rate
+
+    Args:
+        model: Model identifier string (any known variant)
+        input_tokens: Prompt/context tokens consumed
+        output_tokens: Generated/completion tokens produced
+        cache_read_tokens: Tokens served from cache (discounted)
+        cache_write_tokens: Tokens written to cache (premium)
+        reasoning_tokens: Tokens spent on internal reasoning (GPT-o series)
+
+    Returns:
+        Estimated cost in USD (0.0 for unknown/local models)
+    """
+    model_lower = model.lower().strip()
+
+    # Try exact match first
+    rates = COSTS.get(model_lower)
+
+    # Fuzzy match: try to find a key that's contained in the model name
+    if rates is None:
+        for key, val in COSTS.items():
+            if key in model_lower or model_lower in key:
+                rates = val
+                break
+
+    if rates is None:
+        # Unknown / local model — cost is $0
+        return 0.0
+
+    input_rate, output_rate = rates  # per 1M tokens
+
+    cost = 0.0
+    cost += (input_tokens / 1_000_000) * input_rate
+    cost += (output_tokens / 1_000_000) * output_rate
+
+    # Cache adjustments (Anthropic-style)
+    if cache_read_tokens:
+        cost += (cache_read_tokens / 1_000_000) * (input_rate * 0.1)
+    if cache_write_tokens:
+        cost += (cache_write_tokens / 1_000_000) * (input_rate * 1.25)
+
+    # Reasoning tokens billed as output tokens (OpenAI o-series pattern)
+    if reasoning_tokens:
+        cost += (reasoning_tokens / 1_000_000) * output_rate
+
+    return round(cost, 8)
+
+
+def get_model_rates(model: str) -> tuple[float, float] | None:
+    """
+    Look up per-million-token rates for a model.
+    Returns (input_rate, output_rate) or None if unknown.
+    """
+    model_lower = model.lower().strip()
+    rates = COSTS.get(model_lower)
+    if rates is None:
+        for key, val in COSTS.items():
+            if key in model_lower or model_lower in key:
+                return val
+    return rates