kivi-cli 2.0.6__py3-none-any.whl

kiviai/services/providers/openai_agent.py

@@ -0,0 +1,113 @@
+"""OpenAI Agent SDK provider — uses openai-agents package."""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from typing import AsyncIterator
+
+from .base import BaseProvider, ProviderConfig, ProviderEvent, EventType
+
+
+class OpenAIAgentProvider(BaseProvider):
+    name = "openai-agent"
+    display_name = "OpenAI Agent"
+    description = "OpenAI's agent SDK with built-in tool use, handoffs, and guardrails. Runs multi-step workflows with GPT models. Supports streaming and sub-agent delegation. Requires OPENAI_API_KEY."
+    supports_streaming = True
+    supports_tools = True
+    supports_sessions = False
+    supports_agents = True
+    available_models = [
+        "gpt-5.4", "gpt-5-mini", "gpt-4.1", "gpt-4.1-mini",
+        "gpt-4.1-nano", "o3", "o3-mini", "o4-mini",
+    ]
+
+    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("OPENAI_API_KEY", "")
+        model = config.model or "gpt-4o"
+
+        if not api_key:
+            yield ProviderEvent(type=EventType.ERROR, content="OPENAI_API_KEY not set")
+            return
+
+        try:
+            from openai import AsyncOpenAI
+
+            client = AsyncOpenAI(api_key=api_key)
+
+            messages = []
+            if history:
+                for h in history:
+                    if h.get("role") in ("user", "assistant", "system") and not h.get("metadata"):
+                        messages.append({"role": h["role"], "content": h["content"]})
+            messages.append({"role": "user", "content": prompt})
+
+            stream = await client.chat.completions.create(
+                model=model,
+                messages=messages,
+                stream=True,
+                max_tokens=4096,
+            )
+
+            text_buf = ""
+            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:
+                    text_buf += delta.content
+                    yield ProviderEvent(type=EventType.TEXT, content=delta.content)
+
+                if chunk.choices and chunk.choices[0].finish_reason:
+                    break
+
+        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
+
+        # Emit cost event from usage metadata on last chunk
+        from .model_costs import estimate_cost
+        input_tokens = 0
+        output_tokens = 0
+        if last_chunk and hasattr(last_chunk, 'usage') and last_chunk.usage:
+            input_tokens = last_chunk.usage.prompt_tokens or 0
+            output_tokens = last_chunk.usage.completion_tokens or 0
+
+        usage = {
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+        }
+        total_cost = estimate_cost(
+            model,
+            input_tokens=input_tokens,
+            output_tokens=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("OPENAI_API_KEY", "")
+        return {"status": "ok" if api_key else "no_api_key", "provider": self.name}

kiviai/services/providers/opencode.py

@@ -0,0 +1,157 @@
+"""OpenCode provider — wraps `opencode run --format json`.
+
+Event types from opencode CLI:
+  step_start  — new LLM turn begins
+  text        — streaming text chunk
+  tool_use    — tool announced + completed (state has input/output/error)
+  step_finish — step done with token/cost info
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import AsyncIterator
+
+from .base import BaseProvider, ProviderConfig, ProviderEvent, EventType
+
+
+class OpenCodeProvider(BaseProvider):
+    name = "opencode"
+    display_name = "OpenCode"
+    description = "Open-source agentic coding CLI. File editing, shell access, and step-by-step reasoning with tool use. Supports persistent sessions and multiple LLM backends."
+    supports_streaming = True
+    supports_tools = True
+    supports_sessions = True
+    available_models = [
+        # opencode/* are free-tier models served by OpenCode itself (no API key
+        # needed) — verified live via `opencode models`. This list drifts as
+        # OpenCode rotates free models in/out; re-run `opencode models` to refresh.
+        "opencode/big-pickle", "opencode/deepseek-v4-flash-free", "opencode/hy3-free",
+        "opencode/mimo-v2.5-free", "opencode/nemotron-3-ultra-free", "opencode/north-mini-code-free",
+        # Below require the user's own provider credentials (`opencode auth login`).
+        "anthropic/claude-sonnet-5", "anthropic/claude-opus-4-8", "anthropic/claude-haiku-4-5",
+        "openai/gpt-5.4", "openai/gpt-4.1", "openai/gpt-4.1-mini", "openai/o3", "openai/o4-mini",
+        
+    ]
+
+    def __init__(self):
+        self._stop = False
+        self._proc = None
+
+    async def run(self, prompt: str, config: ProviderConfig, history=None) -> AsyncIterator[ProviderEvent]:
+        self._stop = False
+        cmd = ["opencode", "run", "--format", "json"]
+        if config.model:
+            cmd += ["--model", config.model]
+        if config.session_id:
+            cmd += ["--session", config.session_id]
+        if config.cwd:
+            cmd += ["--dir", config.cwd]
+        if config.extra.get("thinking"):
+            cmd += ["--thinking"]
+        if config.extra.get("fork"):
+            cmd += ["--fork"]
+
+        # File attachments via -f flag
+        for f in config.extra.get("files", []):
+            cmd += ["-f", f]
+
+        cmd += [prompt]
+
+        session_id = None
+        total_cost = 0.0
+        usage = {}
+
+        try:
+            self._proc = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                stdin=asyncio.subprocess.DEVNULL,
+            )
+
+            async for line in self._proc.stdout:
+                if self._stop:
+                    self._proc.terminate()
+                    yield ProviderEvent(type=EventType.TEXT, content="⏹ *stopped*")
+                    yield ProviderEvent(type=EventType.DONE)
+                    return
+
+                line = line.decode().strip()
+                if not line or not line.startswith("{"):
+                    continue
+                try:
+                    msg = json.loads(line)
+                except Exception:
+                    continue
+
+                session_id = msg.get("sessionID", session_id)
+                mtype = msg.get("type")
+                part = msg.get("part", {})
+
+                if mtype == "text":
+                    yield ProviderEvent(type=EventType.TEXT, content=part.get("text", ""))
+
+                elif mtype == "error":
+                    error_data = msg.get("error", {})
+                    error_msg = error_data.get("data", {}).get("message", "") or error_data.get("name", "Unknown error")
+                    yield ProviderEvent(type=EventType.ERROR, content=f"OpenCode error: {error_msg}")
+                    return
+
+                elif mtype == "tool_use":
+                    state = part.get("state", {})
+                    tool_name = part.get("tool", "tool")
+                    title = part.get("title", tool_name) or tool_name
+                    args = json.dumps(state.get("input", {}), indent=2)
+                    output = state.get("output", "") or state.get("error", "")
+                    if isinstance(output, list):
+                        output = "\n".join(c.get("text", str(c)) for c in output)
+                    status = state.get("status", "")
+                    is_error = status == "error" or bool(state.get("error"))
+
+                    yield ProviderEvent(
+                        type=EventType.TOOL_START,
+                        metadata={"title": f"⚙ {title}", "args": args},
+                    )
+                    yield ProviderEvent(
+                        type=EventType.TOOL_RESULT,
+                        content=str(output),
+                        metadata={"is_error": is_error},
+                    )
+
+                elif mtype == "step_finish":
+                    tokens = part.get("tokens", {})
+                    cache = tokens.get("cache", {})
+                    step_cost = part.get("cost", 0.0)
+                    total_cost += step_cost
+                    usage["input_tokens"] = usage.get("input_tokens", 0) + tokens.get("input", 0)
+                    usage["output_tokens"] = usage.get("output_tokens", 0) + tokens.get("output", 0)
+                    usage["cache_read_input_tokens"] = usage.get("cache_read_input_tokens", 0) + cache.get("read", 0)
+                    usage["cache_creation_input_tokens"] = usage.get("cache_creation_input_tokens", 0) + cache.get("write", 0)
+
+            await self._proc.wait()
+        except Exception as e:
+            yield ProviderEvent(type=EventType.ERROR, content=str(e))
+            return
+
+        if session_id or total_cost:
+            yield ProviderEvent(
+                type=EventType.COST,
+                metadata={
+                    "session_id": session_id,
+                    "total_cost_usd": total_cost,
+                    "usage": usage,
+                },
+            )
+
+        yield ProviderEvent(type=EventType.DONE)
+
+    async def stop(self):
+        self._stop = True
+        if self._proc:
+            self._proc.terminate()
+
+    async def health_check(self):
+        import shutil
+        has_bin = shutil.which("opencode") is not None
+        return {"status": "ok" if has_bin else "unavailable", "provider": self.name}

kiviai/services/providers/orchestrator_provider.py

@@ -0,0 +1,163 @@
+"""Multi-agent orchestrator provider — supervisor pattern with parallel workers."""
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+from typing import AsyncIterator
+
+from .base import BaseProvider, ProviderConfig, ProviderEvent, EventType
+
+
+class OrchestratorProvider(BaseProvider):
+    name = "claudeagents"
+    display_name = "Multi-Agent Orchestrator"
+    description = "Supervisor-worker pattern for parallel execution. Breaks complex tasks into subtasks, runs them across multiple Claude agents simultaneously, then synthesizes results. Best for large refactors, multi-file changes, and research tasks."
+    supports_streaming = True
+    supports_tools = True
+    supports_sessions = False
+    supports_agents = True
+    available_models = ["claude-sonnet-4.6"]
+
+    def __init__(self):
+        self._stop = False
+
+    async def run(self, prompt: str, config: ProviderConfig, history=None) -> AsyncIterator[ProviderEvent]:
+        """Supervisor loop: plan → parallel workers → review → repeat."""
+        self._stop = False
+
+        # Import Claude provider for worker execution
+        from .claude import ClaudeProvider
+        from .registry import get_provider
+
+        cwd = config.cwd or "."
+        mode = config.mode or "bypassPermissions"
+
+        # Step 1: Plan subtasks using supervisor
+        yield ProviderEvent(
+            type=EventType.TOOL_START,
+            metadata={"title": "🎯 Supervisor", "args": "Planning subtasks…"},
+        )
+
+        plan_prompt = (
+            "You are a task supervisor. Break this into independent subtasks for parallel execution.\n"
+            f'Respond ONLY with a JSON array: [{{"id":"1","prompt":"...","model":"haiku"}}]\n'
+            f"Use 'haiku' for most tasks. Use 'sonnet' only for complex reasoning.\n\n"
+            f"User request: {prompt}\nWorking directory: {cwd}"
+        )
+
+        try:
+            supervisor = ClaudeProvider()
+            plan_config = ProviderConfig(mode=mode, cwd=cwd)
+            plan_text = ""
+            async for event in supervisor.run(plan_prompt, plan_config):
+                if event.type == EventType.TEXT:
+                    plan_text += event.content
+                elif event.type == EventType.COST:
+                    yield event
+
+            # Parse plan
+            plan_text = plan_text.strip()
+            if plan_text.startswith("```"):
+                plan_text = "\n".join(plan_text.split("\n")[1:])
+                if plan_text.endswith("```"):
+                    plan_text = plan_text[:-3]
+
+            try:
+                parsed = json.loads(plan_text.strip())
+            except json.JSONDecodeError:
+                match = re.search(r'\[.*\]', plan_text, re.DOTALL)
+                if match:
+                    parsed = json.loads(match.group())
+                else:
+                    parsed = [{"id": "1", "prompt": prompt, "model": "haiku"}]
+
+            if isinstance(parsed, dict):
+                subtasks = parsed.get("tasks", [parsed])
+            else:
+                subtasks = parsed
+
+            yield ProviderEvent(
+                type=EventType.TOOL_RESULT,
+                content=f"Planned {len(subtasks)} subtask(s)",
+                metadata={"title": "🎯 Plan", "is_error": False},
+            )
+
+            # Step 2: Run workers in parallel
+            MODEL_MAP = {
+                "haiku": "claude-haiku-4-5-20251001",
+                "sonnet": "claude-sonnet-4-6",
+            }
+
+            for st in subtasks:
+                worker_id = st.get("id", "1")
+                worker_prompt = st.get("prompt", prompt)
+                model_key = st.get("model", "haiku")
+                model = MODEL_MAP.get(model_key, MODEL_MAP["haiku"])
+
+                yield ProviderEvent(
+                    type=EventType.AGENT_GROUP,
+                    metadata={
+                        "agent_id": worker_id,
+                        "agent_label": f"Agent {worker_id} ({model_key})",
+                        "model": model,
+                        "status": "running",
+                        "children": [],
+                    },
+                )
+
+            # Execute workers
+            async def run_worker(st):
+                worker_id = st.get("id", "1")
+                worker_prompt = st.get("prompt", prompt)
+                model_key = st.get("model", "haiku")
+                model = MODEL_MAP.get(model_key, MODEL_MAP["haiku"])
+
+                worker = ClaudeProvider()
+                worker_config = ProviderConfig(
+                    mode=mode, cwd=cwd,
+                    extra={"model_override": model},
+                )
+
+                result_text = ""
+                events = []
+                async for event in worker.run(worker_prompt, worker_config):
+                    if event.type == EventType.TEXT:
+                        result_text += event.content
+                    events.append(event)
+
+                return {"id": worker_id, "text": result_text, "events": events, "model": model_key}
+
+            results = await asyncio.gather(*[run_worker(st) for st in subtasks])
+
+            # Update agent groups with results
+            for r in results:
+                yield ProviderEvent(
+                    type=EventType.AGENT_GROUP,
+                    metadata={
+                        "agent_id": r["id"],
+                        "agent_label": f"Agent {r['id']} ({r['model']})",
+                        "model": r["model"],
+                        "status": "done",
+                        "children": [{"role": "assistant", "content": r["text"]}],
+                    },
+                )
+
+            # Step 3: Summarize
+            summary_parts = []
+            for r in results:
+                summary_parts.append(f"Agent {r['id']}: {r['text'][:200]}")
+
+            yield ProviderEvent(
+                type=EventType.TEXT,
+                content=f"All {len(results)} agent(s) completed.\n\n" + "\n\n".join(summary_parts),
+            )
+
+        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

kiviai/services/providers/registry.py

@@ -0,0 +1,89 @@
+"""
+Provider registry — maps model names to provider classes.
+Single source of truth for which providers are available.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Type
+
+from .base import BaseProvider, ProviderConfig
+
+log = logging.getLogger("cc-ui.registry")
+
+_PROVIDERS: dict[str, Type[BaseProvider]] = {}
+_ALIASES: dict[str, str] = {}
+
+
+def register(name: str, provider_cls: Type[BaseProvider], aliases: list[str] | None = None):
+    """Register a provider class under a canonical name."""
+    _PROVIDERS[name] = provider_cls
+    if aliases:
+        for alias in aliases:
+            _ALIASES[alias] = name
+
+
+def get_provider(name: str) -> BaseProvider:
+    """Instantiate a provider by name or alias."""
+    canonical = _ALIASES.get(name, name)
+    cls = _PROVIDERS.get(canonical)
+    if cls is None:
+        available = list(_PROVIDERS.keys()) + list(_ALIASES.keys())
+        raise ValueError(f"Unknown provider '{name}'. Available: {available}")
+    return cls()
+
+
+def list_providers() -> list[dict]:
+    """Return capabilities of all registered providers."""
+    seen = set()
+    result = []
+    for name, cls in _PROVIDERS.items():
+        if name not in seen:
+            seen.add(name)
+            instance = cls()
+            info = instance.get_capabilities()
+            info["aliases"] = [a for a, c in _ALIASES.items() if c == name]
+            result.append(info)
+    return result
+
+
+async def health_check_all() -> dict:
+    """Run health checks on all providers."""
+    results = {}
+    for name, cls in _PROVIDERS.items():
+        try:
+            instance = cls()
+            results[name] = await instance.health_check()
+        except Exception as e:
+            results[name] = {"status": "error", "error": str(e)}
+    return results
+
+
+def _auto_register():
+    """Auto-register all built-in providers."""
+    try:
+        from .claude import ClaudeProvider
+        register("claude", ClaudeProvider, aliases=["claude-code", "cc", "sonnet", "opus", "haiku"])
+    except ImportError as e:
+        log.debug("Claude provider not available: %s", e)
+
+    try:
+        from .opencode import OpenCodeProvider
+        register("opencode", OpenCodeProvider, aliases=["oc"])
+    except ImportError as e:
+        log.debug("OpenCode provider not available: %s", e)
+
+    try:
+        from .copilot import CopilotProvider
+        register("copilot", CopilotProvider, aliases=["gh-copilot"])
+    except ImportError as e:
+        log.debug("Copilot provider not available: %s", e)
+
+    try:
+        from .vllm import VLLMProvider
+        register("vllm", VLLMProvider, aliases=["local", "vllm-local"])
+    except ImportError as e:
+        log.debug("vLLM provider not available: %s", e)
+
+
+_auto_register()