donkit-llm 0.1.7__tar.gz → 0.1.9__tar.gz

{donkit_llm-0.1.7 → donkit_llm-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: donkit-llm
-Version: 0.1.7
+Version: 0.1.9
 Summary: Unified LLM model implementations for Donkit (OpenAI, Azure OpenAI, Claude, Vertex AI, Ollama)
 License: MIT
 Author: Donkit AI

{donkit_llm-0.1.7 → donkit_llm-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "donkit-llm"
-version = "0.1.7"
+version = "0.1.9"
 description = "Unified LLM model implementations for Donkit (OpenAI, Azure OpenAI, Claude, Vertex AI, Ollama)"
 authors = ["Donkit AI <opensource@donkit.ai>"]
 license = "MIT"
@@ -19,6 +19,7 @@ donkit-ragops-api-gateway-client = "^0.1.5"
 ruff = "^0.13.3"
 pytest = "^8.4.2"
 pytest-asyncio = "^1.3.0"
+donkit-llm-gate-client = { path = "../llm-gate-client", develop = true }
 
 [build-system]
 requires = ["poetry-core>=1.9.0"]

{donkit_llm-0.1.7 → donkit_llm-0.1.9}/src/donkit/llm/__init__.py

@@ -26,6 +26,12 @@ from .factory import ModelFactory
 from .gemini_model import GeminiModel, GeminiEmbeddingModel
 from .donkit_model import DonkitModel
 
+
+try:
+    from .llm_gate_model import LLMGateModel
+except ModuleNotFoundError:
+    LLMGateModel = None
+
 __all__ = [
     "ModelFactory",
     # Abstract base
@@ -58,3 +64,6 @@ __all__ = [
     "GeminiEmbeddingModel",
     "DonkitModel",
 ]
+
+if LLMGateModel is not None:
+    __all__.append("LLMGateModel")

{donkit_llm-0.1.7 → donkit_llm-0.1.9}/src/donkit/llm/factory.py

@@ -4,6 +4,11 @@ from .claude_model import ClaudeModel
 from .claude_model import ClaudeVertexModel
 from .donkit_model import DonkitModel
 from .gemini_model import GeminiModel
+
+try:
+    from .llm_gate_model import LLMGateModel
+except ModuleNotFoundError:
+    LLMGateModel = None
 from .model_abstract import LLMModelAbstract
 from .openai_model import AzureOpenAIEmbeddingModel
 from .openai_model import AzureOpenAIModel
@@ -174,6 +179,30 @@ class ModelFactory:
             model_name=model_name,
         )
 
+    @staticmethod
+    def create_llm_gate_model(
+        model_name: str | None,
+        base_url: str,
+        provider: str = "default",
+        embedding_provider: str | None = None,
+        embedding_model_name: str | None = None,
+        user_id: str | None = None,
+        project_id: str | None = None,
+    ) -> LLMGateModel:
+        if LLMGateModel is None:
+            raise ImportError(
+                "Provider 'llm_gate' requires optional dependency 'donkit-llm-gate-client'"
+            )
+        return LLMGateModel(
+            base_url=base_url,
+            provider=provider,
+            model_name=model_name,
+            embedding_provider=embedding_provider,
+            embedding_model_name=embedding_model_name,
+            user_id=user_id,
+            project_id=project_id,
+        )
+
     @staticmethod
     def create_model(
         provider: Literal[
@@ -184,6 +213,7 @@ class ModelFactory:
             "vertex",
             "ollama",
             "donkit",
+            "llm_gate",
         ],
         model_name: str | None,
         credentials: dict,
@@ -198,6 +228,7 @@ class ModelFactory:
                 "vertex": "gemini-2.5-flash",
                 "ollama": "mistral",
                 "donkit": None,
+                "llm_gate": None,
             }
             model_name = default_models.get(provider, "default")
         if provider == "openai":
@@ -258,5 +289,15 @@ class ModelFactory:
                 api_key=credentials["api_key"],
                 base_url=credentials["base_url"],
             )
+        elif provider == "llm_gate":
+            return ModelFactory.create_llm_gate_model(
+                model_name=model_name,
+                base_url=credentials["base_url"],
+                provider=credentials.get("provider", "default"),
+                embedding_provider=credentials.get("embedding_provider"),
+                embedding_model_name=credentials.get("embedding_model_name"),
+                user_id=credentials.get("user_id"),
+                project_id=credentials.get("project_id"),
+            )
         else:
             raise ValueError(f"Unknown provider: {provider}")

donkit_llm-0.1.9/src/donkit/llm/llm_gate_model.py

@@ -0,0 +1,210 @@
+from typing import Any, AsyncIterator
+
+from .model_abstract import (
+    EmbeddingRequest,
+    EmbeddingResponse,
+    FunctionCall,
+    GenerateRequest,
+    GenerateResponse,
+    LLMModelAbstract,
+    Message,
+    ModelCapability,
+    StreamChunk,
+    Tool,
+    ToolCall,
+)
+
+
+class LLMGateModel(LLMModelAbstract):
+    name = "llm_gate"
+
+    @staticmethod
+    def _get_client() -> type:
+        try:
+            from donkit.llm_gate.client import LLMGate
+
+            return LLMGate
+        except Exception as e:
+            raise ImportError(
+                "LLMGateModel requires 'donkit-llm-gate-client' to be installed"
+            ) from e
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:8002",
+        provider: str = "default",
+        model_name: str | None = None,
+        embedding_provider: str | None = None,
+        embedding_model_name: str | None = None,
+        user_id: str | None = None,
+        project_id: str | None = None,
+    ):
+        self.base_url = base_url
+        self.provider = provider
+        self._model_name = model_name
+        self.embedding_provider = embedding_provider
+        self.embedding_model_name = embedding_model_name
+        self.user_id = user_id
+        self.project_id = project_id
+        self._capabilities = self._determine_capabilities()
+
+    @property
+    def model_name(self) -> str:
+        return self._model_name or "default"
+
+    @model_name.setter
+    def model_name(self, value: str):
+        self._model_name = value
+        self._capabilities = self._determine_capabilities()
+
+    @property
+    def capabilities(self) -> ModelCapability:
+        return self._capabilities
+
+    def _determine_capabilities(self) -> ModelCapability:
+        caps = (
+            ModelCapability.TEXT_GENERATION
+            | ModelCapability.STREAMING
+            | ModelCapability.STRUCTURED_OUTPUT
+            | ModelCapability.TOOL_CALLING
+            | ModelCapability.MULTIMODAL_INPUT
+            | ModelCapability.EMBEDDINGS
+        )
+        return caps
+
+    def _convert_message(self, msg: Message) -> dict:
+        result: dict[str, Any] = {"role": msg.role}
+        if isinstance(msg.content, str):
+            result["content"] = msg.content
+        else:
+            content_parts = []
+            for part in msg.content if msg.content else []:
+                content_parts.append(part.model_dump(exclude_none=True))
+            result["content"] = content_parts
+        if msg.tool_calls:
+            result["tool_calls"] = [tc.model_dump() for tc in msg.tool_calls]
+        if msg.tool_call_id:
+            result["tool_call_id"] = msg.tool_call_id
+        if msg.name:
+            result["name"] = msg.name
+        return result
+
+    def _convert_tools(self, tools: list[Tool]) -> list[dict]:
+        return [tool.model_dump(exclude_none=True) for tool in tools]
+
+    def _prepare_generate_kwargs(self, request: GenerateRequest) -> dict:
+        messages = [self._convert_message(msg) for msg in request.messages]
+        tools_payload = self._convert_tools(request.tools) if request.tools else None
+
+        kwargs: dict[str, Any] = {
+            "provider": self.provider,
+            "model_name": self.model_name,
+            "messages": messages,
+            "user_id": self.user_id,
+            "project_id": self.project_id,
+        }
+
+        if request.temperature is not None:
+            kwargs["temperature"] = request.temperature
+        if request.max_tokens is not None:
+            kwargs["max_tokens"] = request.max_tokens
+        if request.top_p is not None:
+            kwargs["top_p"] = request.top_p
+        if request.stop:
+            kwargs["stop"] = request.stop
+        if tools_payload:
+            kwargs["tools"] = tools_payload
+            if request.tool_choice:
+                if isinstance(request.tool_choice, (str, dict)):
+                    kwargs["tool_choice"] = request.tool_choice
+                else:
+                    kwargs["tool_choice"] = "auto"
+        if request.response_format:
+            kwargs["response_format"] = request.response_format
+
+        return kwargs
+
+    async def generate(self, request: GenerateRequest) -> GenerateResponse:
+        await self.validate_request(request)
+
+        kwargs = self._prepare_generate_kwargs(request)
+
+        llm_gate = self._get_client()
+
+        async with llm_gate(base_url=self.base_url) as client:
+            response = await client.generate(**kwargs)
+
+        tool_calls = None
+        if response.tool_calls:
+            tool_calls = [
+                ToolCall(
+                    id=tc.id,
+                    type=tc.type,
+                    function=FunctionCall(
+                        name=tc.function.name,
+                        arguments=tc.function.arguments,
+                    ),
+                )
+                for tc in response.tool_calls
+            ]
+
+        return GenerateResponse(
+            content=response.content,
+            tool_calls=tool_calls,
+            finish_reason=response.finish_reason,
+            usage=response.usage,
+            metadata=response.metadata,
+        )
+
+    async def generate_stream(
+        self, request: GenerateRequest
+    ) -> AsyncIterator[StreamChunk]:
+        await self.validate_request(request)
+
+        kwargs = self._prepare_generate_kwargs(request)
+
+        llm_gate = self._get_client()
+
+        async with llm_gate(base_url=self.base_url) as client:
+            async for chunk in client.generate_stream(**kwargs):
+                tool_calls = None
+                if chunk.tool_calls:
+                    tool_calls = [
+                        ToolCall(
+                            id=tc.id,
+                            type=tc.type,
+                            function=FunctionCall(
+                                name=tc.function.name,
+                                arguments=tc.function.arguments,
+                            ),
+                        )
+                        for tc in chunk.tool_calls
+                    ]
+
+                yield StreamChunk(
+                    content=chunk.content,
+                    tool_calls=tool_calls,
+                    finish_reason=chunk.finish_reason,
+                )
+
+    async def embed(self, request: EmbeddingRequest) -> EmbeddingResponse:
+        provider = self.embedding_provider or self.provider
+        model_name = self.embedding_model_name
+
+        llm_gate = self._get_client()
+
+        async with llm_gate(base_url=self.base_url) as client:
+            response = await client.embeddings(
+                provider=provider,
+                input=request.input,
+                model_name=model_name,
+                dimensions=request.dimensions,
+                user_id=self.user_id,
+                project_id=self.project_id,
+            )
+
+        return EmbeddingResponse(
+            embeddings=response.embeddings,
+            usage=response.usage,
+            metadata=response.metadata,
+        )