@agentunion/kite 1.0.6 → 1.2.0

package/extensions/services/web/vendor/conversation/llm.py

@@ -0,0 +1,534 @@
+"""LLM (Large Language Model) abstraction with OpenAI / Claude / Gemini support."""
+
+from __future__ import annotations
+
+import json
+import logging
+from abc import ABC, abstractmethod
+from typing import Any
+
+import httpx
+
+from .. import config as cfg
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Abstract base
+# ---------------------------------------------------------------------------
+
+class LLMProvider(ABC):
+    """Base class for all LLM providers."""
+
+    @abstractmethod
+    async def generate(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+    ) -> dict[str, Any]:
+        """Generate a response.
+
+        Returns ``{"content": str, "tool_calls": list | None}``.
+        """
+        ...
+
+    @abstractmethod
+    async def list_models(self) -> list[dict[str, Any]]:
+        """List models available on this provider's endpoint."""
+        ...
+
+
+# ---------------------------------------------------------------------------
+# Helper utilities shared by all providers
+# ---------------------------------------------------------------------------
+
+async def should_end_call(provider: LLMProvider, messages: list[dict[str, Any]]) -> bool:
+    """Ask the LLM whether the conversation should naturally end now.
+
+    Appends a lightweight system prompt asking for a yes/no JSON answer.
+    """
+    check_messages = messages.copy()
+    check_messages.append({
+        "role": "system",
+        "content": (
+            "Based on the conversation so far, should this phone call end now? "
+            "Answer with ONLY a JSON object: {\"should_end\": true} or {\"should_end\": false}. "
+            "The call should end if: the task is complete, the other party said goodbye, "
+            "or there is nothing more to discuss."
+        ),
+    })
+    try:
+        result = await provider.generate(check_messages)
+        text = result.get("content", "")
+        # Try to parse JSON from the response
+        if "{" in text:
+            payload = json.loads(text[text.index("{"):text.rindex("}") + 1])
+            return bool(payload.get("should_end", False))
+    except Exception:
+        logger.debug("should_end_call check failed, defaulting to False")
+    return False
+
+
+async def generate_summary(provider: LLMProvider, messages: list[dict[str, Any]]) -> str:
+    """Generate a concise call summary from the conversation history."""
+    summary_messages = messages.copy()
+    summary_messages.append({
+        "role": "system",
+        "content": (
+            "Please generate a concise summary of this phone call in Chinese. Include:\n"
+            "1. The purpose of the call\n"
+            "2. Key points discussed\n"
+            "3. Outcome / agreements reached\n"
+            "4. Any follow-up items\n"
+            "Keep it under 300 characters."
+        ),
+    })
+    try:
+        result = await provider.generate(summary_messages)
+        return result.get("content", "")
+    except Exception:
+        logger.exception("Failed to generate call summary")
+        return ""
+
+
+# ---------------------------------------------------------------------------
+# OpenAI-compatible provider
+# ---------------------------------------------------------------------------
+
+class OpenAILLM(LLMProvider):
+    """OpenAI / OpenAI-compatible chat completions API."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        model: str,
+        temperature: float = 0.7,
+        max_tokens: int = 1024,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+
+    async def generate(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+    ) -> dict[str, Any]:
+        url = f"{self.base_url}/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+        body: dict[str, Any] = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+        }
+        if tools:
+            body["tools"] = tools
+            body["tool_choice"] = "auto"
+
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            resp = await client.post(url, headers=headers, json=body)
+            resp.raise_for_status()
+            data = resp.json()
+
+        choice = data["choices"][0]
+        message = choice["message"]
+        content = message.get("content", "") or ""
+        tool_calls_raw = message.get("tool_calls")
+
+        tool_calls: list[dict[str, Any]] | None = None
+        if tool_calls_raw:
+            tool_calls = []
+            for tc in tool_calls_raw:
+                func = tc.get("function", {})
+                arguments = func.get("arguments", "{}")
+                if isinstance(arguments, str):
+                    try:
+                        arguments = json.loads(arguments)
+                    except json.JSONDecodeError:
+                        arguments = {}
+                tool_calls.append({
+                    "id": tc.get("id", ""),
+                    "name": func.get("name", ""),
+                    "arguments": arguments,
+                })
+
+        return {
+            "content": content,
+            "tool_calls": tool_calls,
+            "raw_tool_calls": tool_calls_raw,
+        }
+
+    async def list_models(self) -> list[dict[str, Any]]:
+        url = f"{self.base_url}/models"
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.get(url, headers=headers)
+            resp.raise_for_status()
+            data = resp.json()
+        return data.get("data", [])
+
+
+# ---------------------------------------------------------------------------
+# Anthropic Claude provider
+# ---------------------------------------------------------------------------
+
+class ClaudeLLM(LLMProvider):
+    """Anthropic Claude Messages API."""
+
+    ANTHROPIC_VERSION = "2023-06-01"
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        model: str,
+        temperature: float = 0.7,
+        max_tokens: int = 1024,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+
+    async def generate(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+    ) -> dict[str, Any]:
+        url = f"{self.base_url}/messages"
+        headers = {
+            "x-api-key": self.api_key,
+            "anthropic-version": self.ANTHROPIC_VERSION,
+            "Content-Type": "application/json",
+        }
+
+        # Convert OpenAI-style messages to Claude format
+        system_text, claude_messages = self._convert_messages(messages)
+
+        body: dict[str, Any] = {
+            "model": self.model,
+            "messages": claude_messages,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+        }
+        if system_text:
+            body["system"] = system_text
+        if tools:
+            body["tools"] = self._convert_tools(tools)
+
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            resp = await client.post(url, headers=headers, json=body)
+            resp.raise_for_status()
+            data = resp.json()
+
+        # Parse Claude response content blocks
+        content_text = ""
+        tool_calls: list[dict[str, Any]] | None = None
+
+        for block in data.get("content", []):
+            if block["type"] == "text":
+                content_text += block.get("text", "")
+            elif block["type"] == "tool_use":
+                if tool_calls is None:
+                    tool_calls = []
+                tool_calls.append({
+                    "id": block.get("id", ""),
+                    "name": block.get("name", ""),
+                    "arguments": block.get("input", {}),
+                })
+
+        return {"content": content_text, "tool_calls": tool_calls}
+
+    async def list_models(self) -> list[dict[str, Any]]:
+        url = f"{self.base_url}/models"
+        headers = {
+            "x-api-key": self.api_key,
+            "anthropic-version": self.ANTHROPIC_VERSION,
+        }
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.get(url, headers=headers)
+            resp.raise_for_status()
+            data = resp.json()
+        return data.get("data", [])
+
+    # -- format converters --
+
+    @staticmethod
+    def _convert_messages(
+        messages: list[dict[str, Any]],
+    ) -> tuple[str, list[dict[str, Any]]]:
+        """Convert OpenAI-style messages to Claude format.
+
+        Returns (system_text, claude_messages).
+        """
+        system_parts: list[str] = []
+        claude_msgs: list[dict[str, Any]] = []
+
+        for msg in messages:
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_parts.append(content)
+            elif role == "assistant":
+                # Check if this is a tool-call result message (has tool_calls)
+                if msg.get("tool_calls"):
+                    # Build content blocks for tool use
+                    blocks: list[dict[str, Any]] = []
+                    if content:
+                        blocks.append({"type": "text", "text": content})
+                    for tc in msg["tool_calls"]:
+                        blocks.append({
+                            "type": "tool_use",
+                            "id": tc.get("id", ""),
+                            "name": tc.get("name", ""),
+                            "input": tc.get("arguments", {}),
+                        })
+                    claude_msgs.append({"role": "assistant", "content": blocks})
+                else:
+                    claude_msgs.append({"role": "assistant", "content": content})
+            elif role == "tool":
+                # Tool result -- Claude uses role "user" with tool_result content blocks
+                claude_msgs.append({
+                    "role": "user",
+                    "content": [{
+                        "type": "tool_result",
+                        "tool_use_id": msg.get("tool_call_id", ""),
+                        "content": content,
+                    }],
+                })
+            elif role == "user":
+                claude_msgs.append({"role": "user", "content": content})
+
+        system_text = "\n\n".join(system_parts)
+        return system_text, claude_msgs
+
+    @staticmethod
+    def _convert_tools(tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Convert OpenAI-style tool definitions to Claude format.
+
+        OpenAI: {"type": "function", "function": {"name": ..., "description": ..., "parameters": ...}}
+        Claude: {"name": ..., "description": ..., "input_schema": ...}
+        """
+        claude_tools: list[dict[str, Any]] = []
+        for tool in tools:
+            if tool.get("type") == "function":
+                func = tool["function"]
+                claude_tools.append({
+                    "name": func["name"],
+                    "description": func.get("description", ""),
+                    "input_schema": func.get("parameters", {"type": "object", "properties": {}}),
+                })
+            else:
+                # Assume already in a compatible format
+                claude_tools.append(tool)
+        return claude_tools
+
+
+# ---------------------------------------------------------------------------
+# Google Gemini provider
+# ---------------------------------------------------------------------------
+
+class GeminiLLM(LLMProvider):
+    """Google Gemini (Generative Language API)."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        model: str,
+        temperature: float = 0.7,
+        max_tokens: int = 1024,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+
+    async def generate(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+    ) -> dict[str, Any]:
+        url = f"{self.base_url}/models/{self.model}:generateContent?key={self.api_key}"
+        headers = {"Content-Type": "application/json"}
+
+        system_instruction, contents = self._convert_messages(messages)
+
+        body: dict[str, Any] = {
+            "contents": contents,
+            "generationConfig": {
+                "temperature": self.temperature,
+                "maxOutputTokens": self.max_tokens,
+            },
+        }
+        if system_instruction:
+            body["systemInstruction"] = {"parts": [{"text": system_instruction}]}
+        if tools:
+            body["tools"] = self._convert_tools(tools)
+
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            resp = await client.post(url, headers=headers, json=body)
+            resp.raise_for_status()
+            data = resp.json()
+
+        # Parse Gemini response
+        content_text = ""
+        tool_calls: list[dict[str, Any]] | None = None
+
+        candidates = data.get("candidates", [])
+        if candidates:
+            parts = candidates[0].get("content", {}).get("parts", [])
+            for part in parts:
+                if "text" in part:
+                    content_text += part["text"]
+                elif "functionCall" in part:
+                    if tool_calls is None:
+                        tool_calls = []
+                    fc = part["functionCall"]
+                    tool_calls.append({
+                        "id": f"gemini_{fc.get('name', '')}",
+                        "name": fc.get("name", ""),
+                        "arguments": fc.get("args", {}),
+                    })
+
+        return {"content": content_text, "tool_calls": tool_calls}
+
+    async def list_models(self) -> list[dict[str, Any]]:
+        url = f"{self.base_url}/models?key={self.api_key}"
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.get(url)
+            resp.raise_for_status()
+            data = resp.json()
+        return data.get("models", [])
+
+    # -- format converters --
+
+    @staticmethod
+    def _convert_messages(
+        messages: list[dict[str, Any]],
+    ) -> tuple[str, list[dict[str, Any]]]:
+        """Convert OpenAI-style messages to Gemini format.
+
+        Returns (system_instruction_text, contents).
+        """
+        system_parts: list[str] = []
+        contents: list[dict[str, Any]] = []
+
+        for msg in messages:
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+
+            if role == "system":
+                system_parts.append(content)
+            elif role == "user":
+                contents.append({"role": "user", "parts": [{"text": content}]})
+            elif role == "assistant":
+                parts: list[dict[str, Any]] = []
+                if content:
+                    parts.append({"text": content})
+                # Include tool calls as functionCall parts
+                if msg.get("tool_calls"):
+                    for tc in msg["tool_calls"]:
+                        parts.append({
+                            "functionCall": {
+                                "name": tc.get("name", ""),
+                                "args": tc.get("arguments", {}),
+                            }
+                        })
+                if parts:
+                    contents.append({"role": "model", "parts": parts})
+            elif role == "tool":
+                # Tool result -- Gemini uses functionResponse
+                contents.append({
+                    "role": "function",
+                    "parts": [{
+                        "functionResponse": {
+                            "name": msg.get("name", ""),
+                            "response": {"result": content},
+                        }
+                    }],
+                })
+
+        system_text = "\n\n".join(system_parts)
+        return system_text, contents
+
+    @staticmethod
+    def _convert_tools(tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Convert OpenAI-style tool definitions to Gemini format.
+
+        Gemini expects: [{"function_declarations": [{"name":..., "description":..., "parameters":...}]}]
+        """
+        declarations: list[dict[str, Any]] = []
+        for tool in tools:
+            if tool.get("type") == "function":
+                func = tool["function"]
+                declarations.append({
+                    "name": func["name"],
+                    "description": func.get("description", ""),
+                    "parameters": func.get("parameters", {"type": "object", "properties": {}}),
+                })
+            else:
+                # Assume it has name/description/parameters directly
+                declarations.append({
+                    "name": tool.get("name", ""),
+                    "description": tool.get("description", ""),
+                    "parameters": tool.get("parameters", {"type": "object", "properties": {}}),
+                })
+        return [{"function_declarations": declarations}]
+
+
+# ---------------------------------------------------------------------------
+# Factory
+# ---------------------------------------------------------------------------
+
+def create_llm_provider() -> LLMProvider:
+    """Create an LLM provider instance based on the active provider configuration."""
+    active = cfg.get("llm.active_provider", "openai")
+    provider_cfg = cfg.get(f"llm.providers.{active}", {})
+
+    if not provider_cfg:
+        raise ValueError(f"No configuration found for LLM provider: {active}")
+
+    base_url = provider_cfg.get("base_url", "")
+    api_key = provider_cfg.get("api_key", "")
+    model = provider_cfg.get("model", "")
+    temperature = provider_cfg.get("temperature", 0.7)
+    max_tokens = provider_cfg.get("max_tokens", 1024)
+
+    if active == "openai":
+        return OpenAILLM(
+            base_url=base_url,
+            api_key=api_key,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+    elif active == "claude":
+        return ClaudeLLM(
+            base_url=base_url,
+            api_key=api_key,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+    elif active == "gemini":
+        return GeminiLLM(
+            base_url=base_url,
+            api_key=api_key,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+    else:
+        raise ValueError(f"Unknown LLM provider: {active}")