donkit-llm 0.1.6__tar.gz → 0.1.8__tar.gz

{donkit_llm-0.1.6 → donkit_llm-0.1.8}/PKG-INFO

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

{donkit_llm-0.1.6 → donkit_llm-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "donkit-llm"
-version = "0.1.6"
+version = "0.1.8"
 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.6 → donkit_llm-0.1.8}/src/donkit/llm/__init__.py

@@ -26,6 +26,13 @@ from .factory import ModelFactory
 from .gemini_model import GeminiModel, GeminiEmbeddingModel
 from .donkit_model import DonkitModel
 
+import importlib.util
+
+if importlib.util.find_spec("donkit.llm_gate.client") is not None:
+    from .llm_gate_model import LLMGateModel
+else:
+    LLMGateModel = None
+
 __all__ = [
     "ModelFactory",
     # Abstract base
@@ -58,3 +65,6 @@ __all__ = [
     "GeminiEmbeddingModel",
     "DonkitModel",
 ]
+
+if LLMGateModel is not None:
+    __all__.append("LLMGateModel")

{donkit_llm-0.1.6 → donkit_llm-0.1.8}/src/donkit/llm/factory.py

@@ -4,6 +4,13 @@ from .claude_model import ClaudeModel
 from .claude_model import ClaudeVertexModel
 from .donkit_model import DonkitModel
 from .gemini_model import GeminiModel
+
+import importlib.util
+
+if importlib.util.find_spec("donkit.llm_gate.client") is not None:
+    from .llm_gate_model import LLMGateModel
+else:
+    LLMGateModel = None
 from .model_abstract import LLMModelAbstract
 from .openai_model import AzureOpenAIEmbeddingModel
 from .openai_model import AzureOpenAIModel
@@ -174,6 +181,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 +215,7 @@ class ModelFactory:
             "vertex",
             "ollama",
             "donkit",
+            "llm_gate",
         ],
         model_name: str | None,
         credentials: dict,
@@ -198,6 +230,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 +291,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.8/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,
+        )

{donkit_llm-0.1.6 → donkit_llm-0.1.8}/src/donkit/llm/openai_model.py

@@ -45,27 +45,29 @@ class OpenAIModel(LLMModelAbstract):
 
     def _clean_schema_for_openai(self, schema: dict, is_gpt5: bool = False) -> dict:
         """Clean JSON Schema for OpenAI strict mode.
-        
+
         Args:
             schema: JSON Schema to clean
             is_gpt5: Currently unused - both GPT-4o and GPT-5 support title/description
-        
+
         OpenAI Structured Outputs supports:
             - title and description (useful metadata for the model)
             - Automatically adds additionalProperties: false for all objects
             - Recursively processes nested objects and arrays
-        
+
         Note: The main requirement is additionalProperties: false for all objects,
         which is automatically added by this method.
         """
         cleaned = {}
-        
+
         # Copy all fields, recursively processing nested structures
         for key, value in schema.items():
             if key == "properties" and isinstance(value, dict):
                 # Recursively clean properties
                 cleaned["properties"] = {
-                    k: self._clean_schema_for_openai(v, is_gpt5) if isinstance(v, dict) else v
+                    k: self._clean_schema_for_openai(v, is_gpt5)
+                    if isinstance(v, dict)
+                    else v
                     for k, v in value.items()
                 }
             elif key == "items" and isinstance(value, dict):
@@ -73,11 +75,11 @@ class OpenAIModel(LLMModelAbstract):
                 cleaned["items"] = self._clean_schema_for_openai(value, is_gpt5)
             else:
                 cleaned[key] = value
-        
+
         # Ensure additionalProperties is false for objects (required by OpenAI)
         if cleaned.get("type") == "object" and "additionalProperties" not in cleaned:
             cleaned["additionalProperties"] = False
-            
+
         return cleaned
 
     def _get_base_model_name(self) -> str:
@@ -93,9 +95,9 @@ class OpenAIModel(LLMModelAbstract):
         Reasoning models don't support temperature, top_p, presence_penalty, frequency_penalty.
         They only support max_completion_tokens (not max_tokens).
         """
-        model_lower = self._get_base_model_name().lower()
+        model_lower = self.model_name.lower()
         # Check for reasoning model prefixes
-        reasoning_prefixes = ("gpt-5", "o1", "o3", "o4")
+        reasoning_prefixes = ("gpt-5", "o1", "o3", "o4", "deepseek")
         return any(model_lower.startswith(prefix) for prefix in reasoning_prefixes)
 
     def _supports_max_completion_tokens(self) -> bool:
@@ -333,6 +335,18 @@ class OpenAIModel(LLMModelAbstract):
         messages = [self._convert_message(msg) for msg in request.messages]
         kwargs = self._build_request_kwargs(request, messages, stream=False)
 
+        # Log request to LLM
+        # request_log = {
+        #     "model": self._model_name,
+        #     "messages": messages,
+        #     "temperature": kwargs.get("temperature"),
+        #     "max_tokens": kwargs.get("max_tokens")
+        #     or kwargs.get("max_completion_tokens"),
+        #     "top_p": kwargs.get("top_p"),
+        #     "tools": kwargs.get("tools"),
+        #     "tool_choice": kwargs.get("tool_choice"),
+        # }
+
         try:
             response = await self.client.chat.completions.create(**kwargs)
 
@@ -359,6 +373,33 @@ class OpenAIModel(LLMModelAbstract):
                     for tc in message.tool_calls
                 ]
 
+            # Log response from LLM
+            # response_log = {
+            #     "content": content,
+            #     "tool_calls": [
+            #         {
+            #             "id": tc.id,
+            #             "type": tc.type,
+            #             "function": {
+            #                 "name": tc.function.name,
+            #                 "arguments": tc.function.arguments,
+            #             },
+            #         }
+            #         for tc in (message.tool_calls or [])
+            #     ],
+            #     "finish_reason": choice.finish_reason,
+            #     "usage": {
+            #         "prompt_tokens": response.usage.prompt_tokens,
+            #         "completion_tokens": response.usage.completion_tokens,
+            #         "total_tokens": response.usage.total_tokens,
+            #     }
+            #     if response.usage
+            #     else None,
+            # }
+            # logger.info(
+            #     f"LLM Response (generate): {json.dumps(response_log, ensure_ascii=False, indent=2)}"
+            # )
+
             return GenerateResponse(
                 content=content,
                 tool_calls=tool_calls,
@@ -384,6 +425,22 @@ class OpenAIModel(LLMModelAbstract):
         messages = [self._convert_message(msg) for msg in request.messages]
         kwargs = self._build_request_kwargs(request, messages, stream=True)
 
+        # Log request to LLM
+        # request_log = {
+        #     "model": self._model_name,
+        #     "messages": messages,
+        #     "temperature": kwargs.get("temperature"),
+        #     "max_tokens": kwargs.get("max_tokens")
+        #     or kwargs.get("max_completion_tokens"),
+        #     "top_p": kwargs.get("top_p"),
+        #     "tools": kwargs.get("tools"),
+        #     "tool_choice": kwargs.get("tool_choice"),
+        #     "stream": True,
+        # }
+        # logger.info(
+        #     f"LLM Request (generate_stream): {json.dumps(request_log, ensure_ascii=False, indent=2)}"
+        # )
+
         try:
             stream = await self.client.chat.completions.create(**kwargs)
 
@@ -399,6 +456,11 @@ class OpenAIModel(LLMModelAbstract):
 
                 # Yield text content if present
                 if delta.content:
+                    # Log chunk content: uncomment to debug
+                    # chunk_log = {"content": delta.content}
+                    # logger.info(
+                    #     f"LLM Stream Chunk: {json.dumps(chunk_log, ensure_ascii=False)}"
+                    # )
                     yield StreamChunk(content=delta.content, tool_calls=None)
 
                 # Accumulate tool calls
@@ -443,6 +505,21 @@ class OpenAIModel(LLMModelAbstract):
                     )
                     for tc_data in accumulated_tool_calls.values()
                 ]
+                # Log final tool calls
+                # tool_calls_log = [
+                #     {
+                #         "id": tc.id,
+                #         "type": tc.type,
+                #         "function": {
+                #             "name": tc.function.name,
+                #             "arguments": tc.function.arguments,
+                #         },
+                #     }
+                #     for tc in tool_calls
+                # ]
+                # logger.info(
+                #     f"LLM Stream Final Tool Calls: {json.dumps(tool_calls_log, ensure_ascii=False, indent=2)}"
+                # )
                 yield StreamChunk(content=None, tool_calls=tool_calls)
 
         except Exception as e:

donkit_llm-0.1.6/src/donkit/llm/ollama_integration.py

@@ -1,442 +0,0 @@
-#!/usr/bin/env python3
-"""Test script for Ollama LLM provider integration."""
-
-import asyncio
-import json
-
-import pytest
-
-from llm_gate.models import ModelCapability
-from .factory import ModelFactory
-from .model_abstract import (
-    ContentPart,
-    ContentType,
-    EmbeddingRequest,
-    GenerateRequest,
-    Message,
-)
-from .openai_model import OpenAIModel
-
-
-def test_ollama_model_creation() -> None:
-    """Test that Ollama model initializes correctly."""
-    print("=" * 60)
-    print("TEST 1: Ollama Model Creation via Factory")
-    print("=" * 60)
-
-    credentials = {
-        "api_key": "ollama",
-        "base_url": "http://localhost:11434/v1",
-    }
-
-    try:
-        model = ModelFactory.create_model(
-            provider="ollama",
-            model_name="gpt-oss:20b-cloud",
-            credentials=credentials,
-        )
-        print(f"✅ Model created: {model.__class__.__name__}")
-        print(f"   Model name: {model.model_name}")
-        print(f"   Is OpenAI model: {isinstance(model, OpenAIModel)}")
-    except Exception as e:
-        print(f"❌ Failed to create model: {e}")
-        raise
-
-
-def test_openai_model_direct_creation() -> None:
-    """Test direct OpenAI model creation for Ollama."""
-    print("\n" + "=" * 60)
-    print("TEST 2: Direct OpenAI Model Creation for Ollama")
-    print("=" * 60)
-
-    try:
-        model = ModelFactory.create_openai_model(
-            model_name="gpt-oss:20b-cloud",
-            api_key="ollama",
-            base_url="http://localhost:11434/v1",
-        )
-        print(f"✅ Model created: {model.__class__.__name__}")
-        print(f"   Model name: {model.model_name}")
-        print(f"   Has client: {hasattr(model, 'client')}")
-        print(f"   Client type: {type(model.client).__name__}")
-    except Exception as e:
-        print(f"❌ Failed to create model: {e}")
-        raise
-
-
-def test_embedding_model_creation() -> None:
-    """Test embedding model creation for Ollama."""
-    print("\n" + "=" * 60)
-    print("TEST 3: Embedding Model Creation")
-    print("=" * 60)
-
-    try:
-        # OpenAI embedding model with Ollama base URL
-        model = ModelFactory.create_embedding_model(
-            provider="openai",
-            model_name="nomic-embed-text",
-            api_key="ollama",
-            base_url="http://localhost:11434/v1",
-        )
-        print(f"✅ Embedding model created: {model.__class__.__name__}")
-        print(f"   Model name: {model.model_name}")
-    except Exception as e:
-        print(f"❌ Failed to create embedding model: {e}")
-        raise
-
-
-def test_model_configuration() -> None:
-    """Test model configuration."""
-    print("\n" + "=" * 60)
-    print("TEST 4: Model Configuration")
-    print("=" * 60)
-
-    try:
-        model = ModelFactory.create_openai_model(
-            model_name="gpt-oss:20b-cloud",
-            api_key="ollama",
-            base_url="http://localhost:11434/v1",
-        )
-
-        config = {
-            "model_name": model.model_name,
-            "model_type": model.__class__.__name__,
-            "has_client": hasattr(model, "client"),
-            "capabilities": str(model.capabilities),
-        }
-
-        print("✅ Model configuration:")
-        print(json.dumps(config, indent=2, default=str))
-    except Exception as e:
-        print(f"❌ Failed to get model configuration: {e}")
-        raise
-
-
-def test_factory_provider_support() -> None:
-    """Test that factory supports ollama provider."""
-    print("\n" + "=" * 60)
-    print("TEST 5: Factory Provider Support")
-    print("=" * 60)
-
-    credentials = {
-        "api_key": "ollama",
-        "base_url": "http://localhost:11434/v1",
-    }
-
-    try:
-        # Test all supported providers
-        providers = ["openai", "ollama"]
-        for provider in providers:
-            model = ModelFactory.create_model(
-                provider=provider,
-                model_name="test-model",
-                credentials=credentials,
-            )
-            print(f"✅ Provider '{provider}' supported: {model.__class__.__name__}")
-    except Exception as e:
-        print(f"❌ Provider support test failed: {e}")
-        raise
-
-
-@pytest.mark.asyncio
-async def test_text_generation() -> None:
-    """Test text generation with Ollama."""
-    print("\n" + "=" * 60)
-    print("TEST 6: Text Generation Request")
-    print("=" * 60)
-
-    credentials = {
-        "api_key": "ollama",
-        "base_url": "http://localhost:11434/v1",
-    }
-
-    try:
-        model = ModelFactory.create_model(
-            provider="ollama",
-            model_name="gpt-oss:20b-cloud",
-            credentials=credentials,
-        )
-
-        request = GenerateRequest(
-            messages=[
-                Message(
-                    role="user", content="Say 'Hello from Ollama!' in one sentence."
-                )
-            ],
-            temperature=0.7,
-            max_tokens=100,
-        )
-
-        print("📤 Sending request to Ollama...")
-        print("   Model: gpt-oss:20b-cloud")
-        print(f"   Message: {request.messages[0].content}")
-
-        response = await model.generate(request)
-
-        print("✅ Generation successful")
-        print(f"   Response: {response.content}")
-
-    except Exception as e:
-        print(f"❌ Generation failed: {e}")
-        raise
-
-
-@pytest.mark.asyncio
-async def test_streaming_generation() -> None:
-    """Test streaming text generation with Ollama."""
-    print("\n" + "=" * 60)
-    print("TEST 7: Streaming Text Generation")
-    print("=" * 60)
-
-    credentials = {
-        "api_key": "ollama",
-        "base_url": "http://localhost:11434/v1",
-    }
-
-    try:
-        model = ModelFactory.create_model(
-            provider="ollama",
-            model_name="gpt-oss:20b-cloud",
-            credentials=credentials,
-        )
-
-        request = GenerateRequest(
-            messages=[
-                Message(role="user", content="Count from 1 to 5, one number per line.")
-            ],
-            temperature=0.5,
-            max_tokens=100,
-        )
-
-        print("📤 Sending streaming request to Ollama...")
-        print("   Model: gpt-oss:20b-cloud")
-        print(f"   Message: {request.messages[0].content}")
-        print("\n   Response stream:")
-
-        full_content = ""
-        async for chunk in model.generate_stream(request):
-            if chunk.content:
-                print(f"   {chunk.content}", end="", flush=True)
-                full_content += chunk.content
-
-        print("\n\n✅ Streaming complete")
-        print(f"   Total content length: {len(full_content)} characters")
-
-    except Exception as e:
-        print(f"❌ Streaming failed: {e}")
-        raise
-
-
-@pytest.mark.asyncio
-async def test_embedding_generation() -> None:
-    """Test embedding generation with Ollama."""
-    print("\n" + "=" * 60)
-    print("TEST 8: Embedding Generation")
-    print("=" * 60)
-    try:
-        model = ModelFactory.create_embedding_model(
-            provider="openai",
-            model_name="embeddinggemma",
-            api_key="ollama",
-            base_url="http://localhost:11434/v1",
-        )
-
-        texts = [
-            "Hello from Ollama!",
-            "This is a test embedding.",
-            "Embedding models are useful for semantic search.",
-        ]
-
-        request = EmbeddingRequest(input=texts)
-
-        print("📤 Sending embedding request to Ollama...")
-        print("   Model: nomic-embed-text")
-        print(f"   Texts to embed: {len(texts)}")
-        for i, text in enumerate(texts, 1):
-            print(f"     {i}. {text}")
-
-        response = await model.embed(request)
-
-        print("✅ Embedding successful")
-        print(f"   Number of embeddings: {len(response.embeddings)}")
-        print(f"   Embedding dimension: {len(response.embeddings[0])}")
-        print(f"   First embedding (first 5 values): {response.embeddings[0][:5]}")
-
-    except Exception as e:
-        print(f"❌ Embedding failed: {e}")
-        raise
-
-
-@pytest.mark.asyncio
-async def test_multimodal_vision() -> None:
-    """Test multimodal vision capabilities with Ollama."""
-    print("\n" + "=" * 60)
-    print("TEST 9: Multimodal Vision (Image Understanding)")
-    print("=" * 60)
-
-    credentials = {
-        "api_key": "ollama",
-        "base_url": "http://localhost:11434/v1",
-    }
-
-    try:
-        model = ModelFactory.create_model(
-            provider="ollama",
-            model_name="qwen3-vl:235b-cloud",
-            credentials=credentials,
-        )
-
-        # Check if model supports vision
-        print("📋 Model capabilities:")
-        print(f"   Vision support: {model.supports_capability(ModelCapability.VISION)}")
-        print(
-            f"   Multimodal input: {model.supports_capability(ModelCapability.MULTIMODAL_INPUT)}"
-        )
-
-        # Create a message with image URL (using a public test image)
-        image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg"
-
-        content_parts = [
-            ContentPart(
-                content_type=ContentType.TEXT,
-                content="What do you see in this image? Describe it briefly.",
-            ),
-            ContentPart(
-                content_type=ContentType.IMAGE_URL,
-                content=image_url,
-                mime_type="image/jpeg",
-            ),
-        ]
-
-        message = Message(role="user", content=content_parts)
-
-        request = GenerateRequest(
-            messages=[message],
-            temperature=0.7,
-            max_tokens=200,
-        )
-
-        print("\n📤 Sending multimodal request to Ollama...")
-        print("   Model: gpt-oss:20b-cloud")
-        print(f"   Message parts: {len(content_parts)}")
-        print("     - Text: What do you see in this image?")
-        print(f"     - Image: {image_url}")
-
-        response = await model.generate(request)
-
-        print("\n✅ Vision analysis successful")
-        print(f"   Response: {response.content}")
-
-    except Exception as e:
-        print(f"❌ Vision test failed: {e}")
-        raise
-
-
-@pytest.mark.asyncio
-async def test_multimodal_with_base64() -> None:
-    """Test multimodal with base64 encoded image."""
-    print("\n" + "=" * 60)
-    print("TEST 10: Multimodal with Base64 Image")
-    print("=" * 60)
-
-    credentials = {
-        "api_key": "ollama",
-        "base_url": "http://localhost:11434/v1",
-    }
-
-    try:
-        model = ModelFactory.create_model(
-            provider="ollama",
-            model_name="qwen3-vl:235b-cloud",
-            credentials=credentials,
-        )
-
-        # For this test, we'll use a simple base64 encoded 1x1 pixel image
-        # In real usage, you would encode an actual image
-        base64_image = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
-
-        content_parts = [
-            ContentPart(
-                content_type=ContentType.TEXT,
-                content="Analyze this image and tell me what you see.",
-            ),
-            ContentPart(
-                content_type=ContentType.IMAGE_BASE64,
-                content=base64_image,
-                mime_type="image/png",
-            ),
-        ]
-
-        message = Message(role="user", content=content_parts)
-
-        request = GenerateRequest(
-            messages=[message],
-            temperature=0.5,
-            max_tokens=100,
-        )
-
-        print("📤 Sending base64 image request to Ollama...")
-        print("   Model: gpt-oss:20b-cloud")
-        print(f"   Message parts: {len(content_parts)}")
-        print("     - Text: Analyze this image")
-        print(f"     - Image (base64): {len(base64_image)} characters")
-
-        response = await model.generate(request)
-
-        print("✅ Base64 image analysis successful")
-        print(f"   Response: {response.content}")
-
-    except Exception as e:
-        print(f"❌ Base64 image test failed: {e}")
-        raise
-
-
-async def run_async_tests() -> None:
-    """Run async tests."""
-    try:
-        # await test_text_generation()
-        # await test_streaming_generation()
-        # await test_embedding_generation()
-        await test_multimodal_vision()
-        await test_multimodal_with_base64()
-    except Exception as e:
-        print(f"\n❌ Async tests failed: {e}")
-        raise
-
-
-def main() -> None:
-    """Run all tests."""
-    print("\n")
-    print("╔" + "=" * 58 + "╗")
-    print("║" + " " * 58 + "║")
-    print("║" + "  OLLAMA LLM PROVIDER INTEGRATION TESTS".center(58) + "║")
-    print("║" + " " * 58 + "║")
-    print("╚" + "=" * 58 + "╝")
-
-    try:
-        # Sync tests
-        # test_ollama_model_creation()
-        # test_model_configuration()
-        # test_embedding_model_creation()
-        # test_factory_provider_support()
-        # test_openai_model_direct_creation()
-
-        # Async tests (actual API calls)
-        print("\n" + "=" * 60)
-        print("Running async tests (actual API calls)...")
-        print("=" * 60)
-        asyncio.run(run_async_tests())
-
-        print("\n" + "=" * 60)
-        print("✅ ALL TESTS PASSED!")
-        print("=" * 60 + "\n")
-
-    except Exception as e:
-        print("\n" + "=" * 60)
-        print(f"❌ TESTS FAILED: {e}")
-        print("=" * 60 + "\n")
-        raise
-
-
-if __name__ == "__main__":
-    main()