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

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

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

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

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

@@ -19,6 +19,7 @@ from .openai_model import (
     AzureOpenAIModel,
     OpenAIEmbeddingModel,
     OpenAIModel,
+    is_codex_model,
 )
 from .claude_model import ClaudeModel, ClaudeVertexModel
 from .vertex_model import VertexAIModel, VertexEmbeddingModel
@@ -26,11 +27,10 @@ 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:
+try:
     from .llm_gate_model import LLMGateModel
-else:
+except ModuleNotFoundError:
     LLMGateModel = None
 
 __all__ = [
@@ -57,6 +57,7 @@ __all__ = [
     "AzureOpenAIModel",
     "OpenAIEmbeddingModel",
     "AzureOpenAIEmbeddingModel",
+    "is_codex_model",
     "ClaudeModel",
     "ClaudeVertexModel",
     "VertexAIModel",

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

@@ -5,11 +5,9 @@ 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:
+try:
     from .llm_gate_model import LLMGateModel
-else:
+except ModuleNotFoundError:
     LLMGateModel = None
 from .model_abstract import LLMModelAbstract
 from .openai_model import AzureOpenAIEmbeddingModel
@@ -45,8 +43,9 @@ class ModelFactory:
         api_version: str = "2024-08-01-preview",
         deployment_name: str | None = None,
     ) -> AzureOpenAIModel:
+        effective_model = deployment_name or model_name
         return AzureOpenAIModel(
-            model_name=deployment_name or model_name,
+            model_name=effective_model,
             api_key=api_key,
             azure_endpoint=azure_endpoint,
             api_version=api_version,
@@ -210,6 +209,7 @@ class ModelFactory:
         provider: Literal[
             "openai",
             "azure_openai",
+            "azure_openai_codex",
             "claude",
             "claude_vertex",
             "vertex",
@@ -224,6 +224,7 @@ class ModelFactory:
             default_models = {
                 "openai": "gpt-5-mini",
                 "azure_openai": "gpt-4.1-mini",
+                "azure_openai_codex": "gpt-5.1-codex",
                 "claude": "claude-4-5-sonnet",
                 "claude_vertex": "claude-4-5-sonnet",
                 "gemini": "gemini-2.5-flash",

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

@@ -1,5 +1,6 @@
 from typing import Any, AsyncIterator
 
+from loguru import logger
 from openai import AsyncAzureOpenAI, AsyncOpenAI
 
 from .model_abstract import (
@@ -268,10 +269,12 @@ class OpenAIModel(LLMModelAbstract):
         # Reasoning models (GPT-5, o1, o3, o4) don't support temperature/top_p
         # They use fixed temperature=1 and top_p=1 internally
         if not is_reasoning:
-            if request.temperature is not None:
-                kwargs["temperature"] = request.temperature
             if request.top_p is not None:
                 kwargs["top_p"] = request.top_p
+            if request.temperature is not None and request.top_p is None:
+                kwargs["temperature"] = request.temperature
+            else:
+                kwargs["top_p"] = 0.0
 
         # Handle max_tokens vs max_completion_tokens
         if request.max_tokens is not None:
@@ -449,6 +452,7 @@ class OpenAIModel(LLMModelAbstract):
 
             async for chunk in stream:
                 if not chunk.choices:
+                    logger.info("No choices in chunk, continue")
                     continue
 
                 choice = chunk.choices[0]
@@ -461,7 +465,7 @@ class OpenAIModel(LLMModelAbstract):
                     # logger.info(
                     #     f"LLM Stream Chunk: {json.dumps(chunk_log, ensure_ascii=False)}"
                     # )
-                    yield StreamChunk(content=delta.content, tool_calls=None)
+                    yield StreamChunk(content=delta.content)
 
                 # Accumulate tool calls
                 if delta.tool_calls:
@@ -528,7 +532,7 @@ class OpenAIModel(LLMModelAbstract):
 
 
 class AzureOpenAIModel(OpenAIModel):
-    """Azure OpenAI model implementation."""
+    """Azure OpenAI model implementation with dynamic Codex support."""
 
     def __init__(
         self,
@@ -554,6 +558,7 @@ class AzureOpenAIModel(OpenAIModel):
         self._api_version = api_version
         self._model_name = model_name
         self._deployment_name = deployment_name
+        self._is_codex = is_codex_model(deployment_name or model_name)
 
         # Call parent constructor (will call our overridden _init_client)
         super().__init__(model_name, api_key)
@@ -564,13 +569,21 @@ class AzureOpenAIModel(OpenAIModel):
         base_url: str | None = None,
         organization: str | None = None,
     ) -> None:
-        """Initialize Azure OpenAI client."""
-        self.client = AsyncAzureOpenAI(
-            api_key=self._api_key,
-            azure_endpoint=self._azure_endpoint,
-            api_version=self._api_version,
-            azure_deployment=self._deployment_name,
-        )
+        """Initialize Azure OpenAI client (or Responses API client for Codex)."""
+        if self._is_codex:
+            # Codex models use Responses API with /openai/v1/ path
+            responses_base_url = f"{self._azure_endpoint.rstrip('/')}/openai/v1/"
+            self.client = AsyncOpenAI(
+                api_key=self._api_key,
+                base_url=responses_base_url,
+            )
+        else:
+            self.client = AsyncAzureOpenAI(
+                api_key=self._api_key,
+                azure_endpoint=self._azure_endpoint,
+                api_version=self._api_version,
+                azure_deployment=self._deployment_name,
+            )
 
     def _determine_capabilities(self) -> ModelCapability:
         """Determine capabilities based on base model name."""
@@ -598,6 +611,7 @@ class AzureOpenAIModel(OpenAIModel):
             value: New deployment name
         """
         self._deployment_name = value
+        self._is_codex = is_codex_model(value)
         # Reinitialize client with new deployment name
         self._init_client(self._api_key)
 
@@ -615,17 +629,276 @@ class AzureOpenAIModel(OpenAIModel):
         """
         self._model_name = value
         self._deployment_name = value
-        self.client = AsyncAzureOpenAI(
-            api_key=self._api_key,
-            azure_endpoint=self._azure_endpoint,
-            api_version=self._api_version,
-            azure_deployment=value,
-        )
+        self._is_codex = is_codex_model(value)
+        self._init_client(self._api_key)
+
+    # ---- Codex (Responses API) helper methods ----
+
+    def _convert_message_for_responses(self, msg: Message) -> dict | list[dict]:
+        """Convert internal Message to Responses API format."""
+        role = msg.role
+        if role == "system":
+            role = "developer"
+
+        if msg.role == "tool" and msg.tool_call_id:
+            return {
+                "type": "function_call_output",
+                "call_id": msg.tool_call_id,
+                "output": msg.content
+                if isinstance(msg.content, str)
+                else str(msg.content),
+            }
+
+        if msg.role == "assistant" and msg.tool_calls:
+            items = []
+            if msg.content:
+                items.append(
+                    {
+                        "type": "message",
+                        "role": "assistant",
+                        "content": [{"type": "output_text", "text": msg.content}],
+                    }
+                )
+            for tc in msg.tool_calls:
+                items.append(
+                    {
+                        "type": "function_call",
+                        "call_id": tc.id,
+                        "name": tc.function.name,
+                        "arguments": tc.function.arguments,
+                    }
+                )
+            return items
+
+        if isinstance(msg.content, str):
+            return {"role": role, "content": msg.content}
+
+        content_parts = []
+        for part in msg.content:
+            if part.content_type == ContentType.TEXT:
+                content_parts.append({"type": "input_text", "text": part.content})
+            elif part.content_type == ContentType.IMAGE_URL:
+                content_parts.append({"type": "input_image", "image_url": part.content})
+            elif part.content_type == ContentType.IMAGE_BASE64:
+                content_parts.append(
+                    {
+                        "type": "input_image",
+                        "image_url": f"data:{part.mime_type or 'image/png'};base64,{part.content}",
+                    }
+                )
+        return {"role": role, "content": content_parts}
+
+    def _convert_tools_for_responses(self, tools: list[Tool]) -> list[dict]:
+        """Convert tools to Responses API format."""
+        return [
+            {
+                "type": "function",
+                "name": tool.function.name,
+                "description": tool.function.description or "",
+                "parameters": tool.function.parameters
+                or {"type": "object", "properties": {}},
+            }
+            for tool in tools
+        ]
+
+    def _extract_system_instruction(
+        self, messages: list[Message]
+    ) -> tuple[str | None, list[Message]]:
+        """Extract system message as instructions."""
+        instructions = None
+        remaining = []
+        for msg in messages:
+            if msg.role == "system":
+                content = msg.content if isinstance(msg.content, str) else ""
+                instructions = (
+                    content if instructions is None else instructions + "\n" + content
+                )
+            else:
+                remaining.append(msg)
+        return instructions, remaining
+
+    async def _generate_codex(self, request: GenerateRequest) -> GenerateResponse:
+        """Generate using Responses API for Codex models."""
+        await self.validate_request(request)
+
+        instructions, messages = self._extract_system_instruction(request.messages)
+
+        input_items = []
+        for msg in messages:
+            converted = self._convert_message_for_responses(msg)
+            if isinstance(converted, list):
+                input_items.extend(converted)
+            else:
+                input_items.append(converted)
+
+        kwargs: dict[str, Any] = {"model": self._deployment_name, "input": input_items}
+
+        if instructions:
+            kwargs["instructions"] = instructions
+        if request.max_tokens:
+            kwargs["max_output_tokens"] = max(8192, min(request.max_tokens, 16384))
+        if request.tools:
+            kwargs["tools"] = self._convert_tools_for_responses(request.tools)
+            if request.tool_choice and isinstance(request.tool_choice, str):
+                if request.tool_choice in ("none", "auto", "required"):
+                    kwargs["tool_choice"] = request.tool_choice
+
+        try:
+            response = await self.client.responses.create(**kwargs)
+
+            content = getattr(response, "output_text", None)
+            tool_calls = None
+
+            if hasattr(response, "output") and response.output:
+                parsed_tool_calls = []
+                for item in response.output:
+                    if getattr(item, "type", None) == "function_call":
+                        parsed_tool_calls.append(
+                            ToolCall(
+                                id=getattr(item, "call_id", ""),
+                                type="function",
+                                function=FunctionCall(
+                                    name=getattr(item, "name", ""),
+                                    arguments=getattr(item, "arguments", "{}"),
+                                ),
+                            )
+                        )
+                    elif getattr(item, "type", None) == "message" and not content:
+                        for part in getattr(item, "content", []):
+                            if getattr(part, "type", None) == "output_text":
+                                content = getattr(part, "text", "")
+                                break
+                if parsed_tool_calls:
+                    tool_calls = parsed_tool_calls
+
+            usage = None
+            if hasattr(response, "usage") and response.usage:
+                usage = {
+                    "prompt_tokens": getattr(response.usage, "input_tokens", 0),
+                    "completion_tokens": getattr(response.usage, "output_tokens", 0),
+                    "total_tokens": getattr(response.usage, "total_tokens", 0),
+                }
+
+            return GenerateResponse(
+                content=content,
+                tool_calls=tool_calls,
+                finish_reason=getattr(response, "status", None),
+                usage=usage,
+            )
+        except Exception as e:
+            logger.error(f"Codex API error: {e}")
+            return GenerateResponse(content=f"Error: {e}")
+
+    async def _generate_stream_codex(
+        self, request: GenerateRequest
+    ) -> AsyncIterator[StreamChunk]:
+        """Generate streaming using Responses API for Codex models."""
+        await self.validate_request(request)
+
+        instructions, messages = self._extract_system_instruction(request.messages)
+
+        input_items = []
+        for msg in messages:
+            converted = self._convert_message_for_responses(msg)
+            if isinstance(converted, list):
+                input_items.extend(converted)
+            else:
+                input_items.append(converted)
+        logger.info(input_items)
+
+        kwargs: dict[str, Any] = {
+            "model": self._deployment_name,
+            "input": input_items,
+            "stream": True,
+        }
+
+        if instructions:
+            kwargs["instructions"] = instructions
+        if request.max_tokens:
+            kwargs["max_output_tokens"] = max(8192, min(request.max_tokens, 16384))
+        if request.tools:
+            kwargs["tools"] = self._convert_tools_for_responses(request.tools)
+            if request.tool_choice and isinstance(request.tool_choice, str):
+                if request.tool_choice in ("none", "auto", "required"):
+                    kwargs["tool_choice"] = request.tool_choice
+
+        try:
+            stream = await self.client.responses.create(**kwargs)
+            # Buffer for accumulating function calls by output_index
+            tool_call_buffers: dict[int, dict] = {}
+
+            async for event in stream:
+                logger.info(event)
+                event_type = getattr(event, "type", None)
+
+                if event_type == "response.output_text.delta":
+                    delta = getattr(event, "delta", "")
+                    if delta:
+                        yield StreamChunk(content=delta)
+
+                # Capture function call name when output item is added
+                elif event_type == "response.output_item.added":
+                    item = getattr(event, "item", None)
+                    output_index = getattr(event, "output_index", 0)
+                    if item and getattr(item, "type", None) == "function_call":
+                        tool_call_buffers[output_index] = {
+                            "call_id": getattr(item, "call_id", ""),
+                            "name": getattr(item, "name", ""),
+                            "arguments": "",
+                        }
+
+                elif event_type == "response.function_call_arguments.delta":
+                    output_index = getattr(event, "output_index", 0)
+                    delta = getattr(event, "delta", "")
+                    if output_index in tool_call_buffers:
+                        tool_call_buffers[output_index]["arguments"] += delta
+
+                elif event_type == "response.function_call_arguments.done":
+                    output_index = getattr(event, "output_index", 0)
+                    if output_index in tool_call_buffers:
+                        tc_data = tool_call_buffers[output_index]
+                        # Get final arguments from event, fallback to accumulated
+                        final_args = getattr(event, "arguments", None)
+                        if final_args is None:
+                            final_args = tc_data.get("arguments", "{}")
+                        yield StreamChunk(
+                            tool_calls=[
+                                ToolCall(
+                                    id=tc_data["call_id"],
+                                    type="function",
+                                    function=FunctionCall(
+                                        name=tc_data["name"],
+                                        arguments=final_args,
+                                    ),
+                                )
+                            ],
+                        )
+                        del tool_call_buffers[output_index]
+
+                elif event_type == "response.completed":
+                    response_obj = getattr(event, "response", None)
+                    finish_reason = (
+                        getattr(response_obj, "status", None) if response_obj else None
+                    )
+                    yield StreamChunk(finish_reason=finish_reason)
+
+                elif event_type == "error":
+                    yield StreamChunk(
+                        content=f"Error: {getattr(event, 'message', 'Unknown')}"
+                    )
+
+        except Exception as e:
+            logger.error(f"Codex streaming error: {e}")
+            yield StreamChunk(content=f"Error: {e}")
+
+    # ---- Main generate methods ----
 
     async def generate(self, request: GenerateRequest) -> GenerateResponse:
-        """Generate a response using Azure OpenAI API with parameter adaptation."""
+        """Generate a response using Azure OpenAI API (or Responses API for Codex)."""
+        if self._is_codex:
+            return await self._generate_codex(request)
+
         # Azure OpenAI uses deployment name instead of model name
-        # Temporarily override model_name with deployment_name
         original_model = self._model_name
         self._model_name = self._deployment_name
         try:
@@ -636,7 +909,12 @@ class AzureOpenAIModel(OpenAIModel):
     async def generate_stream(
         self, request: GenerateRequest
     ) -> AsyncIterator[StreamChunk]:
-        """Generate a streaming response using Azure OpenAI API."""
+        """Generate a streaming response using Azure OpenAI API (or Responses API for Codex)."""
+        if self._is_codex:
+            async for chunk in self._generate_stream_codex(request):
+                yield chunk
+            return
+
         # Azure OpenAI uses deployment name instead of model name
         original_model = self._model_name
         self._model_name = self._deployment_name
@@ -850,3 +1128,10 @@ class AzureOpenAIEmbeddingModel(LLMModelAbstract):
             )
         except Exception as e:
             raise Exception(f"Failed to generate embeddings: {e}")
+
+
+def is_codex_model(model_name: str) -> bool:
+    """Check if the model requires Responses API (Codex models)."""
+    codex_patterns = ["codex", "gpt-5.1-codex", "gpt-5-codex"]
+    model_lower = model_name.lower()
+    return any(pattern in model_lower for pattern in codex_patterns)

{donkit_llm-0.1.8 → donkit_llm-0.1.10}/src/donkit/llm/vertex_model.py

@@ -6,6 +6,7 @@ import google.genai as genai
 from google.genai.types import Blob, Content, FunctionDeclaration, Part
 from google.genai.types import Tool as GeminiTool
 from google.oauth2 import service_account
+from loguru import logger
 
 from .model_abstract import (
     ContentType,
@@ -628,15 +629,33 @@ class VertexAIModel(LLMModelAbstract):
             )
 
             async for chunk in stream:
+                logger.info(chunk)
                 text, tool_calls = self._parse_response(chunk)
 
+                # Extract finish_reason from chunk
+                finish_reason = None
+                if hasattr(chunk, "candidates") and chunk.candidates:
+                    cand = chunk.candidates[0]
+                    if hasattr(cand, "finish_reason") and cand.finish_reason:
+                        finish_reason = str(cand.finish_reason)
+
                 # Yield text chunks as they come
                 if text:
-                    yield StreamChunk(content=text, tool_calls=None)
+                    yield StreamChunk(
+                        content=text, tool_calls=None, finish_reason=finish_reason
+                    )
 
                 # Tool calls come in final chunk - yield them separately
                 if tool_calls:
-                    yield StreamChunk(content=None, tool_calls=tool_calls)
+                    yield StreamChunk(
+                        content=None, tool_calls=tool_calls, finish_reason=finish_reason
+                    )
+
+                # If no text and no tool_calls but we have finish_reason, yield it
+                if not text and not tool_calls and finish_reason:
+                    yield StreamChunk(
+                        content=None, tool_calls=None, finish_reason=finish_reason
+                    )
 
         except Exception as e:
             # error_msg = str(e)