kivi-cli 2.0.5__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/gemini.py

@@ -0,0 +1,120 @@
+"""Google Gemini provider — uses google-genai SDK."""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from typing import AsyncIterator
+
+from .base import BaseProvider, ProviderConfig, ProviderEvent, EventType
+
+
+class GeminiProvider(BaseProvider):
+    name = "gemini"
+    display_name = "Google Gemini"
+    description = "Google's multimodal AI. Fast streaming text generation via the Gemini API. Best for quick questions, summaries, and brainstorming. Requires GEMINI_API_KEY."
+    supports_streaming = True
+    supports_tools = False
+    supports_sessions = False
+    available_models = [
+        "gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.0-flash",
+        "gemini-2.0-flash-lite", "gemini-1.5-pro", "gemini-1.5-flash",
+    ]
+
+    def __init__(self):
+        self._stop = False
+
+    async def run(self, prompt: str, config: ProviderConfig, history=None) -> AsyncIterator[ProviderEvent]:
+        self._stop = False
+
+        api_key = config.api_key or os.environ.get("GEMINI_API_KEY") or os.environ.get("GOOGLE_API_KEY", "")
+        model = config.model or "gemini-2.5-flash"
+
+        if not api_key:
+            yield ProviderEvent(type=EventType.ERROR, content="GEMINI_API_KEY not set")
+            return
+
+        try:
+            from google import genai
+            from google.genai import types
+
+            client = genai.Client(api_key=api_key)
+
+            contents = []
+            if history:
+                for h in history:
+                    if h.get("role") in ("user", "assistant") and not h.get("metadata"):
+                        role = "user" if h["role"] == "user" else "model"
+                        contents.append(types.Content(role=role, parts=[types.Part(text=h["content"])]))
+            contents.append(types.Content(role="user", parts=[types.Part(text=prompt)]))
+
+            response = await asyncio.to_thread(
+                lambda: client.models.generate_content_stream(
+                    model=model,
+                    contents=contents,
+                    config=types.GenerateContentConfig(
+                        temperature=0.7,
+                        max_output_tokens=4096,
+                    ),
+                )
+            )
+
+            text_buf = ""
+            total_input_tokens = 0
+            total_output_tokens = 0
+            for chunk in response:
+                if self._stop:
+                    yield ProviderEvent(type=EventType.TEXT, content="⏹ *stopped*")
+                    yield ProviderEvent(type=EventType.DONE)
+                    return
+
+                if chunk.text:
+                    text_buf += chunk.text
+                    yield ProviderEvent(type=EventType.TEXT, content=chunk.text)
+
+                # Capture usage metadata (available in the final chunk or via usage_metadata)
+                if hasattr(chunk, 'usage_metadata') and chunk.usage_metadata:
+                    um = chunk.usage_metadata
+                    total_input_tokens += getattr(um, 'prompt_token_count', 0) or 0
+                    total_output_tokens += getattr(um, 'candidates_token_count', 0) or 0
+
+        except ImportError:
+            yield ProviderEvent(
+                type=EventType.ERROR,
+                content="google-genai package required: pip install google-genai",
+            )
+            return
+        except Exception as e:
+            yield ProviderEvent(type=EventType.ERROR, content=str(e))
+            return
+
+        # Emit cost event with calculated cost from usage
+        from .model_costs import estimate_cost
+        usage = {
+            "input_tokens": total_input_tokens,
+            "output_tokens": total_output_tokens,
+        }
+        total_cost = estimate_cost(
+            model,
+            input_tokens=total_input_tokens,
+            output_tokens=total_output_tokens,
+        )
+        yield ProviderEvent(
+            type=EventType.COST,
+            metadata={
+                "total_cost_usd": total_cost,
+                "usage": usage,
+            },
+        )
+
+        yield ProviderEvent(type=EventType.DONE)
+
+    async def stop(self):
+        self._stop = True
+
+    async def health_check(self):
+        api_key = os.environ.get("GEMINI_API_KEY") or os.environ.get("GOOGLE_API_KEY", "")
+        return {
+            "status": "ok" if api_key else "no_api_key",
+            "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}