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

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

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "donkit-llm"
-version = "0.1.5"
+version = "0.1.7"
 description = "Unified LLM model implementations for Donkit (OpenAI, Azure OpenAI, Claude, Vertex AI, Ollama)"
 authors = ["Donkit AI <opensource@donkit.ai>"]
 license = "MIT"

{donkit_llm-0.1.5 → donkit_llm-0.1.7}/src/donkit/llm/openai_model.py

@@ -43,6 +43,45 @@ class OpenAIModel(LLMModelAbstract):
         self._init_client(api_key, base_url, organization)
         self._capabilities = self._determine_capabilities()
 
+    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
+                    for k, v in value.items()
+                }
+            elif key == "items" and isinstance(value, dict):
+                # Recursively clean array items
+                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:
         """Get base model name for capability/parameter detection.
 
@@ -56,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:
@@ -267,13 +306,18 @@ class OpenAIModel(LLMModelAbstract):
             # If response_format is a JSON Schema dict with "type": "object", wrap it
             if isinstance(request.response_format, dict):
                 if request.response_format.get("type") == "object":
-                    # This is a JSON Schema - wrap it in json_schema format
+                    # This is a JSON Schema - clean and wrap it in json_schema format
+                    # GPT-5 and reasoning models need stricter schema cleaning
+                    is_gpt5 = self._is_reasoning_model()
+                    cleaned_schema = self._clean_schema_for_openai(
+                        request.response_format, is_gpt5=is_gpt5
+                    )
                     kwargs["response_format"] = {
                         "type": "json_schema",
                         "json_schema": {
                             "name": "response",
                             "strict": True,
-                            "schema": request.response_format,
+                            "schema": cleaned_schema,
                         },
                     }
                 else:
@@ -291,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)
 
@@ -317,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,
@@ -342,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)
 
@@ -357,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
@@ -401,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.5/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()