lm-deluge 0.0.68__py3-none-any.whl → 0.0.70__py3-none-any.whl

lm_deluge/__init__.py

@@ -3,6 +3,19 @@ from .file import File
 from .prompt import Conversation, Message
 from .tool import Tool, ToolParams
 
+try:
+    from .mock_openai import (  # noqa
+        APIError,
+        APITimeoutError,
+        BadRequestError,
+        MockAsyncOpenAI,
+        RateLimitError,
+    )
+
+    _has_openai = True
+except ImportError:
+    _has_openai = False
+
 # dotenv.load_dotenv() - don't do this, fucks with other packages
 
 __all__ = [
@@ -15,3 +28,14 @@ __all__ = [
     "ToolParams",
     "File",
 ]
+
+if _has_openai:
+    __all__.extend(
+        [
+            "MockAsyncOpenAI",
+            "APIError",
+            "APITimeoutError",
+            "BadRequestError",
+            "RateLimitError",
+        ]
+    )

lm_deluge/api_requests/chat_reasoning.py

@@ -0,0 +1,4 @@
+# this request type is for models that add "reasoning_content"
+# on top of the openai chat completions. it's important to be separate
+# for providers that expect you to provide back the reasoning content to
+# preserve best performance.

lm_deluge/api_requests/openai.py

@@ -381,7 +381,7 @@ class OpenAIResponsesRequest(APIRequestBase):
                         output = data.get("output", [])
                         if not output:
                             is_error = True
-                            error_message = "No output in response"
+                            error_message = f"No output in response. Status: {data.get('status')}, error: {data.get('error')}, incomplete details: {data.get('incomplete_details')}"
                         else:
                             # Process each output item
                             for item in output:

lm_deluge/mock_openai.py

@@ -0,0 +1,641 @@
+"""
+Mock OpenAI client that implements the AsyncOpenAI interface but uses lm-deluge's
+LLMClient internally. This allows using any lm-deluge-supported provider through
+the standard OpenAI Python SDK interface.
+
+Example usage:
+    from lm_deluge.mock_openai import MockAsyncOpenAI
+
+    # Use Claude through OpenAI interface
+    client = MockAsyncOpenAI(model="claude-sonnet-4")
+    response = await client.chat.completions.create(
+        model="claude-sonnet-4",  # Can override here
+        messages=[{"role": "user", "content": "Hello!"}],
+        temperature=0.7
+    )
+    print(response.choices[0].message.content)
+
+Installation:
+    pip install lm-deluge[openai]
+"""
+
+import json
+import time
+import uuid
+from typing import Any, AsyncIterator, Literal, Union, overload
+
+try:
+    from openai import (
+        APIError,
+        APITimeoutError,
+        BadRequestError,
+        RateLimitError,
+    )
+    from openai.types import Completion
+    from openai.types.chat import (
+        ChatCompletion,
+        ChatCompletionChunk,
+        ChatCompletionMessage,
+        ChatCompletionMessageToolCall,
+    )
+    from openai.types.chat.chat_completion import Choice as ChatCompletionChoice
+    from openai.types.chat.chat_completion_chunk import (
+        Choice as ChunkChoice,
+        ChoiceDelta,
+        ChoiceDeltaToolCall,
+        ChoiceDeltaToolCallFunction,
+    )
+    from openai.types.chat.chat_completion_message_tool_call import Function
+    from openai.types.completion_choice import CompletionChoice as TextCompletionChoice
+    from openai.types.completion_usage import CompletionUsage
+except ImportError:
+    raise ImportError(
+        "The openai package is required to use MockAsyncOpenAI. "
+        "Install it with: pip install lm-deluge[openai]"
+    )
+
+# Re-export exceptions for compatibility
+__all__ = [
+    "MockAsyncOpenAI",
+    "APIError",
+    "APITimeoutError",
+    "BadRequestError",
+    "RateLimitError",
+]
+
+from lm_deluge.client import LLMClient
+from lm_deluge.prompt import Conversation, Message, Part, Text, ToolCall, ToolResult
+
+
+def _messages_to_conversation(messages: list[dict[str, Any]]) -> Conversation:
+    """Convert OpenAI messages format to lm-deluge Conversation."""
+    conv_messages = []
+
+    for msg in messages:
+        role = msg["role"]
+        content = msg.get("content")
+        tool_calls = msg.get("tool_calls")
+        tool_call_id = msg.get("tool_call_id")
+
+        parts: list[Part] = []
+
+        # Handle regular content
+        if content:
+            if isinstance(content, str):
+                parts.append(Text(content))
+            elif isinstance(content, list):
+                # Multi-part content (text, images, etc.)
+                for item in content:
+                    if item.get("type") == "text":
+                        parts.append(Text(item["text"]))
+                    # Could add image support here later
+
+        # Handle tool calls (from assistant)
+        if tool_calls:
+            for tc in tool_calls:
+                # Parse arguments from JSON string to dict
+                args_str = tc["function"]["arguments"]
+                args_dict = (
+                    json.loads(args_str) if isinstance(args_str, str) else args_str
+                )
+                parts.append(
+                    ToolCall(
+                        id=tc["id"],
+                        name=tc["function"]["name"],
+                        arguments=args_dict,
+                    )
+                )
+
+        # Handle tool results (from tool role)
+        if role == "tool" and tool_call_id:
+            parts.append(ToolResult(tool_call_id=tool_call_id, result=content or ""))
+
+        conv_messages.append(Message(role=role, parts=parts))
+
+    return Conversation(messages=conv_messages)
+
+
+def _response_to_chat_completion(
+    response: Any,  # APIResponse
+    model: str,
+    request_id: str | None = None,
+) -> ChatCompletion:
+    """Convert lm-deluge APIResponse to OpenAI ChatCompletion."""
+    if request_id is None:
+        request_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
+
+    # Handle error responses
+    if response.is_error:
+        # For errors, create an empty response with error finish reason
+        message = ChatCompletionMessage(
+            role="assistant",
+            content=response.error_message or "Error occurred",
+        )
+        choice = ChatCompletionChoice(
+            index=0,
+            message=message,
+            finish_reason="stop",  # or could use "error" but that's not standard
+        )
+        return ChatCompletion(
+            id=request_id,
+            choices=[choice],
+            created=int(time.time()),
+            model=model,
+            object="chat.completion",
+            usage=None,
+        )
+
+    # Extract content from response
+    content_text = None
+    tool_calls = None
+
+    if response.content:
+        # Extract text parts
+        text_parts = [p.text for p in response.content.parts if isinstance(p, Text)]
+        if text_parts:
+            content_text = "".join(text_parts)
+
+        # Extract tool calls
+        tool_call_parts = [p for p in response.content.parts if isinstance(p, ToolCall)]
+        if tool_call_parts:
+            tool_calls = [
+                ChatCompletionMessageToolCall(
+                    id=tc.id,
+                    type="function",
+                    function=Function(
+                        name=tc.name,
+                        # Convert dict arguments to JSON string for OpenAI format
+                        arguments=json.dumps(tc.arguments)
+                        if isinstance(tc.arguments, dict)
+                        else tc.arguments,
+                    ),
+                )
+                for tc in tool_call_parts
+            ]
+
+    # Create message
+    message = ChatCompletionMessage(
+        role="assistant",
+        content=content_text,
+        tool_calls=tool_calls,
+    )
+
+    # Create choice
+    choice = ChatCompletionChoice(
+        index=0,
+        message=message,
+        finish_reason=response.finish_reason or "stop",
+    )
+
+    # Create usage
+    usage = None
+    if response.usage:
+        usage = CompletionUsage(
+            prompt_tokens=response.usage.input_tokens,
+            completion_tokens=response.usage.output_tokens,
+            total_tokens=response.usage.input_tokens + response.usage.output_tokens,
+        )
+
+    return ChatCompletion(
+        id=request_id,
+        choices=[choice],
+        created=int(time.time()),
+        model=model,
+        object="chat.completion",
+        usage=usage,
+    )
+
+
+class _AsyncStreamWrapper:
+    """Wrapper to convert lm-deluge streaming to OpenAI ChatCompletionChunk format."""
+
+    def __init__(self, stream: AsyncIterator, model: str, request_id: str):
+        self._stream = stream
+        self._model = model
+        self._request_id = request_id
+        self._first_chunk = True
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self) -> ChatCompletionChunk:
+        chunk = await self._stream.__anext__()
+
+        # Create delta based on chunk content
+        delta = ChoiceDelta()
+
+        if self._first_chunk:
+            delta.role = "assistant"
+            self._first_chunk = False
+
+        # Extract content from chunk
+        if hasattr(chunk, "content") and chunk.content:
+            if isinstance(chunk.content, str):
+                delta.content = chunk.content
+            elif hasattr(chunk.content, "parts"):
+                # Extract text from parts
+                text_parts = [
+                    p.text for p in chunk.content.parts if isinstance(p, Text)
+                ]
+                if text_parts:
+                    delta.content = "".join(text_parts)
+
+                # Extract tool calls from parts
+                tool_call_parts = [
+                    p for p in chunk.content.parts if isinstance(p, ToolCall)
+                ]
+                if tool_call_parts:
+                    delta.tool_calls = [
+                        ChoiceDeltaToolCall(
+                            index=i,
+                            id=tc.id,
+                            type="function",
+                            function=ChoiceDeltaToolCallFunction(
+                                name=tc.name,
+                                # Convert dict arguments to JSON string for OpenAI format
+                                arguments=json.dumps(tc.arguments)
+                                if isinstance(tc.arguments, dict)
+                                else tc.arguments,
+                            ),
+                        )
+                        for i, tc in enumerate(tool_call_parts)
+                    ]
+
+        # Create choice
+        choice = ChunkChoice(
+            index=0,
+            delta=delta,
+            finish_reason=getattr(chunk, "finish_reason", None),
+        )
+
+        return ChatCompletionChunk(
+            id=self._request_id,
+            choices=[choice],
+            created=int(time.time()),
+            model=self._model,
+            object="chat.completion.chunk",
+        )
+
+
+class MockCompletions:
+    """Mock completions resource that implements OpenAI's completions.create interface."""
+
+    def __init__(self, parent: "MockAsyncOpenAI"):
+        self._parent = parent
+
+    @overload
+    async def create(
+        self,
+        *,
+        messages: list[dict[str, Any]],
+        model: str,
+        stream: Literal[False] = False,
+        **kwargs: Any,
+    ) -> ChatCompletion: ...
+
+    @overload
+    async def create(
+        self,
+        *,
+        messages: list[dict[str, Any]],
+        model: str,
+        stream: Literal[True],
+        **kwargs: Any,
+    ) -> AsyncIterator[ChatCompletionChunk]: ...
+
+    async def create(
+        self,
+        *,
+        messages: list[dict[str, Any]],
+        model: str,
+        stream: bool = False,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        max_completion_tokens: int | None = None,
+        top_p: float | None = None,
+        seed: int | None = None,
+        tools: list[dict[str, Any]] | None = None,
+        tool_choice: Any | None = None,
+        reasoning_effort: str | None = None,
+        response_format: dict[str, Any] | None = None,
+        n: int | None = None,
+        stop: str | list[str] | None = None,
+        presence_penalty: float | None = None,
+        frequency_penalty: float | None = None,
+        **kwargs: Any,
+    ) -> Union[ChatCompletion, AsyncIterator[ChatCompletionChunk]]:
+        """
+        Create a chat completion using lm-deluge's LLMClient.
+
+        Args:
+            messages: List of message dictionaries with 'role' and 'content'
+            model: Model identifier (can override client's default model)
+            stream: Whether to stream the response
+            temperature: Sampling temperature (0-2)
+            max_tokens: Max tokens (deprecated, use max_completion_tokens)
+            max_completion_tokens: Max completion tokens
+            top_p: Nucleus sampling parameter
+            seed: Random seed for deterministic sampling
+            tools: List of tool definitions
+            tool_choice: Tool choice strategy
+            reasoning_effort: Reasoning effort for reasoning models
+            response_format: Response format (e.g., {"type": "json_object"})
+            **kwargs: Other parameters (mostly ignored for compatibility)
+
+        Returns:
+            ChatCompletion (non-streaming) or AsyncIterator[ChatCompletionChunk] (streaming)
+        """
+        # Get or create client for this model
+        client = self._parent._get_or_create_client(model)
+
+        # Convert messages to Conversation
+        conversation = _messages_to_conversation(messages)
+
+        # Build sampling params
+        sampling_kwargs = {}
+        if temperature is not None:
+            sampling_kwargs["temperature"] = temperature
+        if max_completion_tokens is not None:
+            sampling_kwargs["max_new_tokens"] = max_completion_tokens
+        elif max_tokens is not None:
+            sampling_kwargs["max_new_tokens"] = max_tokens
+        if top_p is not None:
+            sampling_kwargs["top_p"] = top_p
+        if seed is not None:
+            sampling_kwargs["seed"] = seed
+        if reasoning_effort is not None:
+            sampling_kwargs["reasoning_effort"] = reasoning_effort
+        if response_format and response_format.get("type") == "json_object":
+            sampling_kwargs["json_mode"] = True
+
+        # If sampling params are provided, create a new client with merged params
+        if sampling_kwargs:
+            # Merge with default params
+            merged_params = {**self._parent._default_sampling_params, **sampling_kwargs}
+            client = self._parent._create_client_with_params(model, merged_params)
+
+        # Convert tools if provided
+        lm_tools = None
+        if tools:
+            # For now, just pass through - lm-deluge will handle the format
+            lm_tools = tools
+
+        # Execute request
+        if stream:
+            # Streaming mode
+            request_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
+            # Note: client.stream() is an async generator, not a coroutine
+            # We can directly wrap it
+            stream_iter = client.stream(conversation, tools=lm_tools)
+            # Verify it's a generator, not a coroutine
+            if hasattr(stream_iter, "__anext__"):
+                return _AsyncStreamWrapper(stream_iter, model, request_id)
+            else:
+                # If it's a coroutine, we need to await it first
+                # But this shouldn't happen with the current implementation
+                raise TypeError(f"Expected async generator, got {type(stream_iter)}")
+        else:
+            # Non-streaming mode
+            response = await client.start(conversation, tools=lm_tools)
+            return _response_to_chat_completion(response, model)
+
+
+class MockTextCompletions:
+    """Mock text completions resource for legacy completions API."""
+
+    def __init__(self, parent: "MockAsyncOpenAI"):
+        self._parent = parent
+
+    async def create(
+        self,
+        *,
+        model: str,
+        prompt: str | list[str],
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        top_p: float | None = None,
+        seed: int | None = None,
+        n: int | None = None,
+        stop: str | list[str] | None = None,
+        **kwargs: Any,
+    ) -> Completion:
+        """
+        Create a text completion using lm-deluge's LLMClient.
+
+        Args:
+            model: Model identifier
+            prompt: Text prompt or list of prompts
+            temperature: Sampling temperature
+            max_tokens: Max tokens to generate
+            top_p: Nucleus sampling parameter
+            seed: Random seed
+            n: Number of completions (currently ignored, always returns 1)
+            stop: Stop sequences
+            **kwargs: Other parameters
+
+        Returns:
+            Completion object
+        """
+        # Get or create client for this model
+        client = self._parent._get_or_create_client(model)
+
+        # Handle single prompt
+        if isinstance(prompt, list):
+            # For now, just use the first prompt
+            prompt = prompt[0] if prompt else ""
+
+        # Convert prompt to Conversation
+        conversation = Conversation([Message(role="user", parts=[Text(prompt)])])
+
+        # Build sampling params
+        sampling_kwargs = {}
+        if temperature is not None:
+            sampling_kwargs["temperature"] = temperature
+        if max_tokens is not None:
+            sampling_kwargs["max_new_tokens"] = max_tokens
+        if top_p is not None:
+            sampling_kwargs["top_p"] = top_p
+        if seed is not None:
+            sampling_kwargs["seed"] = seed
+
+        # Create client with merged params if needed
+        if sampling_kwargs:
+            merged_params = {**self._parent._default_sampling_params, **sampling_kwargs}
+            client = self._parent._create_client_with_params(model, merged_params)
+
+        # Execute request
+        response = await client.start(conversation)
+
+        # Convert to Completion format
+        completion_text = None
+        if response.content:
+            text_parts = [p.text for p in response.content.parts if isinstance(p, Text)]
+            if text_parts:
+                completion_text = "".join(text_parts)
+
+        # Create choice
+        choice = TextCompletionChoice(
+            index=0,
+            text=completion_text or "",
+            finish_reason=response.finish_reason or "stop",
+        )
+
+        # Create usage
+        usage = None
+        if response.usage:
+            usage = CompletionUsage(
+                prompt_tokens=response.usage.input_tokens,
+                completion_tokens=response.usage.output_tokens,
+                total_tokens=response.usage.input_tokens + response.usage.output_tokens,
+            )
+
+        return Completion(
+            id=f"cmpl-{uuid.uuid4().hex[:24]}",
+            choices=[choice],
+            created=int(time.time()),
+            model=model,
+            object="text_completion",
+            usage=usage,
+        )
+
+
+class MockChat:
+    """Mock chat resource that provides access to completions."""
+
+    def __init__(self, parent: "MockAsyncOpenAI"):
+        self._parent = parent
+        self._completions = MockCompletions(parent)
+
+    @property
+    def completions(self) -> MockCompletions:
+        """Access the completions resource."""
+        return self._completions
+
+
+class MockAsyncOpenAI:
+    """
+    Mock AsyncOpenAI client that uses lm-deluge's LLMClient internally.
+
+    This allows using any lm-deluge-supported provider (Anthropic, Google, etc.)
+    through the standard OpenAI Python SDK interface.
+
+    Example:
+        # Use Claude through OpenAI interface
+        client = MockAsyncOpenAI(model="claude-sonnet-4")
+        response = await client.chat.completions.create(
+            model="claude-sonnet-4",
+            messages=[{"role": "user", "content": "Hello!"}],
+            temperature=0.7
+        )
+
+    Args:
+        model: Default model to use (can be overridden in create())
+        api_key: API key (optional, for compatibility)
+        organization: Organization ID (optional, for compatibility)
+        project: Project ID (optional, for compatibility)
+        base_url: Base URL (defaults to OpenAI's URL for compatibility)
+        timeout: Request timeout (optional, for compatibility)
+        max_retries: Max retries (defaults to 2 for compatibility)
+        default_headers: Default headers (optional, for compatibility)
+        temperature: Default temperature
+        max_completion_tokens: Default max completion tokens
+        top_p: Default top_p
+        seed: Default seed for deterministic sampling
+        **kwargs: Additional parameters passed to LLMClient
+    """
+
+    def __init__(
+        self,
+        *,
+        model: str | None = None,
+        api_key: str | None = None,
+        organization: str | None = None,
+        project: str | None = None,
+        base_url: str | None = None,
+        timeout: float | None = None,
+        max_retries: int | None = None,
+        default_headers: dict[str, str] | None = None,
+        http_client: Any | None = None,
+        temperature: float | None = None,
+        max_completion_tokens: int | None = None,
+        top_p: float | None = None,
+        seed: int | None = None,
+        **kwargs: Any,
+    ):
+        # OpenAI-compatible attributes
+        self.api_key = api_key
+        self.organization = organization
+        self.project = project
+        self.base_url = base_url or "https://api.openai.com/v1"
+        self.timeout = timeout
+        self.max_retries = max_retries or 2
+        self.default_headers = default_headers
+        self.http_client = http_client
+
+        # Internal attributes
+        self._default_model = model or "gpt-4o-mini"
+        self._default_sampling_params = {}
+
+        if temperature is not None:
+            self._default_sampling_params["temperature"] = temperature
+        if max_completion_tokens is not None:
+            self._default_sampling_params["max_new_tokens"] = max_completion_tokens
+        if top_p is not None:
+            self._default_sampling_params["top_p"] = top_p
+        if seed is not None:
+            self._default_sampling_params["seed"] = seed
+
+        # Additional kwargs for LLMClient
+        self._client_kwargs = kwargs
+
+        # Cache of LLMClient instances by model
+        self._clients: dict[str, Any] = {}
+
+        # Create the default client
+        self._clients[self._default_model] = self._create_client(self._default_model)
+
+        # Create nested resources
+        self._chat = MockChat(self)
+        self._completions = MockTextCompletions(self)
+
+    def _create_client(self, model: str) -> Any:
+        """Create a new LLMClient for the given model."""
+        return LLMClient(
+            model,
+            **self._default_sampling_params,
+            **self._client_kwargs,
+        )
+
+    def _create_client_with_params(self, model: str, params: dict[str, Any]) -> Any:
+        """Create a new LLMClient with specific sampling parameters."""
+        return LLMClient(
+            model,
+            **params,
+            **self._client_kwargs,
+        )
+
+    def _get_or_create_client(self, model: str) -> Any:
+        """Get existing client or create new one for the model."""
+        if model not in self._clients:
+            self._clients[model] = self._create_client(model)
+        return self._clients[model]
+
+    @property
+    def chat(self) -> MockChat:
+        """Access the chat resource."""
+        return self._chat
+
+    @property
+    def completions(self) -> MockTextCompletions:
+        """Access the text completions resource."""
+        return self._completions
+
+    async def close(self) -> None:
+        """
+        Close the client and clean up resources.
+
+        This is provided for compatibility with AsyncOpenAI's close() method.
+        Currently a no-op as LLMClient instances don't need explicit cleanup.
+        """
+        # No cleanup needed for LLMClient instances
+        pass

lm_deluge/models/__init__.py

@@ -15,7 +15,9 @@ from .fireworks import FIREWORKS_MODELS
 from .google import GOOGLE_MODELS
 from .grok import XAI_MODELS
 from .groq import GROQ_MODELS
+from .kimi import KIMI_MODELS
 from .meta import META_MODELS
+from .minimax import MINIMAX_MODELS
 from .mistral import MISTRAL_MODELS
 from .openai import OPENAI_MODELS
 from .openrouter import OPENROUTER_MODELS
@@ -132,7 +134,9 @@ for model_dict in [
     FIREWORKS_MODELS,
     GOOGLE_MODELS,
     XAI_MODELS,
+    KIMI_MODELS,
     META_MODELS,
+    MINIMAX_MODELS,
     MISTRAL_MODELS,
     OPENAI_MODELS,
     OPENROUTER_MODELS,

lm_deluge/models/kimi.py

@@ -0,0 +1,34 @@
+KIMI_MODELS = {
+    "kimi-k2": {
+        "id": "kimi-k2",
+        "name": "kimi-k2-0905-preview",
+        "api_base": "https://api.moonshot.ai/anthropic/v1",
+        "api_key_env_var": "MOONSHOT_API_KEY",
+        "supports_json": True,
+        "api_spec": "anthropic",
+    },
+    "kimi-k2-turbo": {
+        "id": "kimi-k2-turbo",
+        "name": "kimi-k2-turbo-preview",
+        "api_base": "https://api.moonshot.ai/anthropic/v1",
+        "api_key_env_var": "MOONSHOT_API_KEY",
+        "supports_json": True,
+        "api_spec": "anthropic",
+    },
+    "kimi-k2-thinking": {
+        "id": "kimi-k2-thinking",
+        "name": "kimi-k2-thinking",
+        "api_base": "https://api.moonshot.ai/anthropic/v1",
+        "api_key_env_var": "MOONSHOT_API_KEY",
+        "supports_json": True,
+        "api_spec": "anthropic",
+    },
+    "kimi-k2-thinking-turbo": {
+        "id": "kimi-k2-thinking-turbo",
+        "name": "kimi-k2-thinking-turbo",
+        "api_base": "https://api.moonshot.ai/anthropic/v1",
+        "api_key_env_var": "MOONSHOT_API_KEY",
+        "supports_json": True,
+        "api_spec": "anthropic",
+    },
+}

lm_deluge/models/minimax.py

@@ -0,0 +1,10 @@
+MINIMAX_MODELS = {
+    "minimax-m2": {
+        "id": "minimax-m2",
+        "name": "MiniMax-M2",
+        "api_base": "https://api.minimax.io/anthropic/v1",
+        "api_key_env_var": "MINIMAX_API_KEY",
+        "supports_json": False,
+        "api_spec": "anthropic",
+    }
+}

{lm_deluge-0.0.68.dist-info → lm_deluge-0.0.70.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.68
+Version: 0.0.70
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10
@@ -23,6 +23,8 @@ Requires-Dist: pdf2image
 Requires-Dist: pillow
 Requires-Dist: fastmcp>=2.4
 Requires-Dist: rich
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
 Dynamic: license-file
 
 # lm-deluge

{lm_deluge-0.0.68.dist-info → lm_deluge-0.0.70.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lm_deluge/__init__.py,sha256=LKKIcqQoQyDpTck6fnB7iAs75BnfNNa3Bj5Nz7KU4Hk,376
+lm_deluge/__init__.py,sha256=zF5lAitfgJ8A28IXJ5BE9OUCqGOqSnGOWn3ZIlizNyY,822
 lm_deluge/batches.py,sha256=Km6QM5_7BlF2qEyo4WPlhkaZkpzrLqf50AaveHXQOoY,25127
 lm_deluge/cache.py,sha256=xO2AIYvP3tUpTMKQjwQQYfGRJSRi6e7sMlRhLjsS-u4,4873
 lm_deluge/cli.py,sha256=Ilww5gOw3J5v0NReq_Ra4hhxU4BCIJBl1oTGxJZKedc,12065
@@ -8,6 +8,7 @@ lm_deluge/embed.py,sha256=CO-TOlC5kOTAM8lcnicoG4u4K664vCBwHF1vHa-nAGg,13382
 lm_deluge/errors.py,sha256=oHjt7YnxWbh-eXMScIzov4NvpJMo0-2r5J6Wh5DQ1tk,209
 lm_deluge/file.py,sha256=PTmlJQ-IaYcYUFun9V0bJ1NPVP84edJrR0hvCMWFylY,19697
 lm_deluge/image.py,sha256=5AMXmn2x47yXeYNfMSMAOWcnlrOxxOel-4L8QCJwU70,8928
+lm_deluge/mock_openai.py,sha256=dYZDBKgTepQ-yd5zPRYBgMRXO6TeLqiM1fDQe622Ono,22110
 lm_deluge/prompt.py,sha256=Bgszws8-3GPefiVRa-Mht4tfyfoqD_hV5MX1nrbkJn0,63465
 lm_deluge/request_context.py,sha256=cBayMFWupWhde2OjRugW3JH-Gin-WFGc6DK2Mb4Prdc,2576
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
@@ -19,10 +20,11 @@ lm_deluge/api_requests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBd
 lm_deluge/api_requests/anthropic.py,sha256=QGq3G5jJIGcoM2HdRt73GgkvZs4GOViyjYexWex05Vk,8927
 lm_deluge/api_requests/base.py,sha256=GCcydwBRx4_xAuYLvasXlyj-TgqvKAVhVvxRfJkvPbY,9471
 lm_deluge/api_requests/bedrock.py,sha256=Uppne03GcIEk1tVYzoGu7GXK2Sg94a_xvFTLDRN_phY,15412
+lm_deluge/api_requests/chat_reasoning.py,sha256=sJvstvKFqsSBUjYcwxzGt2_FH4cEp3Z6gKcBPyPjGwk,236
 lm_deluge/api_requests/common.py,sha256=BZ3vRO5TB669_UsNKugkkuFSzoLHOYJIKt4nV4sf4vc,422
 lm_deluge/api_requests/gemini.py,sha256=4uD7fQl0yWyAvYkPNi3oO1InBnvYfo5_QR6k-va-2GI,7838
 lm_deluge/api_requests/mistral.py,sha256=8JZP2CDf1XZfaPcTk0WS4q-VfYYj58ptpoH8LD3MQG4,4528
-lm_deluge/api_requests/openai.py,sha256=d1Ddf5sSutx9Ti1riwOEkeADnhYG7Y4vQm2DOhKl67I,25925
+lm_deluge/api_requests/openai.py,sha256=ezlGYNGHFvQGgs-xuxhDDeiEembHhVh_KqJBdRBqSlM,26038
 lm_deluge/api_requests/response.py,sha256=vG194gAH5p7ulpNy4qy5Pryfb1p3ZV21-YGoj__ru3E,7436
 lm_deluge/api_requests/deprecated/bedrock.py,sha256=WrcIShCoO8JCUSlFOCHxg6KQCNTZfw3TpYTvSpYk4mA,11320
 lm_deluge/api_requests/deprecated/cohere.py,sha256=KgDScD6_bWhAzOY5BHZQKSA3kurt4KGENqC4wLsGmcU,5142
@@ -42,7 +44,7 @@ lm_deluge/llm_tools/locate.py,sha256=lYNbKTmy9dTvj0lEQkOQ7yrxyqsgYzjD0C_byJKI_4w
 lm_deluge/llm_tools/ocr.py,sha256=7fDlvs6uUOvbxMasvGGNJx5Fj6biM6z3lijKZaGN26k,23
 lm_deluge/llm_tools/score.py,sha256=9oGA3-k2U5buHQXkXaEI9M4Wb5yysNhTLsPbGeghAlQ,2580
 lm_deluge/llm_tools/translate.py,sha256=iXyYvQZ8bC44FWhBk4qpdqjKM1WFF7Shq-H2PxhPgg4,1452
-lm_deluge/models/__init__.py,sha256=a2xzQNG2axdMaSzoLbzdOKBM5EVOLztvlo8E1k-brqM,4516
+lm_deluge/models/__init__.py,sha256=54H24K_eADbfdEH9aNORrNEXvDLZCQ4TEekeLiWljSE,4619
 lm_deluge/models/anthropic.py,sha256=5j75sB40yZzT1wwKC7Dh0f2Y2cXnp8yxHuXW63PCuns,6285
 lm_deluge/models/bedrock.py,sha256=g1PbfceSRH2lWST3ja0mUlF3oTq4e4T-si6RMe7qXgg,4888
 lm_deluge/models/cerebras.py,sha256=u2FMXJF6xMr0euDRKLKMo_NVTOcvSrrEpehbHr8sSeE,2050
@@ -52,7 +54,9 @@ lm_deluge/models/fireworks.py,sha256=yvt2Ggzye4aUqCqY74ta67Vu7FrQaLFjdFtN4P7D-dc
 lm_deluge/models/google.py,sha256=Hr2MolQoaeY85pKCGO7k7OH_1nQJdrwMgrJbfz5bI8w,5387
 lm_deluge/models/grok.py,sha256=TDzr8yfTaHbdJhwMA-Du6L-efaKFJhjTQViuVElCCHI,2566
 lm_deluge/models/groq.py,sha256=Mi5WE1xOBGoZlymD0UN6kzhH_NOmfJYU4N2l-TO0Z8Q,2552
+lm_deluge/models/kimi.py,sha256=1voigLdNO2CxpWv0KDpQPP3Wolx5WrqgAlYL9ObJFuQ,1117
 lm_deluge/models/meta.py,sha256=BBgnscL1gMcIdPbRqrlDl_q9YAYGSrkw9JkAIabXtLs,1883
+lm_deluge/models/minimax.py,sha256=rwW9gNotAYfDVtMlqmSYegN6GoZM_9DSNNZU2yPOmaU,275
 lm_deluge/models/mistral.py,sha256=x67o5gckBGmPcIGdVbS26XZAYFKBYM4tsxEAahGp8bk,4323
 lm_deluge/models/openai.py,sha256=6J4eAt6Iu5RopokyldUQzRlviFBXBqhLqpVP5tztzqI,11074
 lm_deluge/models/openrouter.py,sha256=O-Po4tmHjAqFIVU96TUL0QnK01R4e2yDN7Z4sYJ-CuE,2120
@@ -65,8 +69,8 @@ lm_deluge/util/logprobs.py,sha256=UkBZakOxWluaLqHrjARu7xnJ0uCHVfLGHJdnYlEcutk,11
 lm_deluge/util/spatial.py,sha256=BsF_UKhE-x0xBirc-bV1xSKZRTUhsOBdGqsMKme20C8,4099
 lm_deluge/util/validation.py,sha256=hz5dDb3ebvZrZhnaWxOxbNSVMI6nmaOODBkk0htAUhs,1575
 lm_deluge/util/xml.py,sha256=Ft4zajoYBJR3HHCt2oHwGfymGLdvp_gegVmJ-Wqk4Ck,10547
-lm_deluge-0.0.68.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.68.dist-info/METADATA,sha256=dSD-PnK2RiwWGsC_-ui4gJ6cQvcXQODAKfod6xUjoXQ,13443
-lm_deluge-0.0.68.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lm_deluge-0.0.68.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.68.dist-info/RECORD,,
+lm_deluge-0.0.70.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.70.dist-info/METADATA,sha256=URQWK2LB1itY_viE7mv0ijJOfUolZMDRzvK-Pdzmn_o,13514
+lm_deluge-0.0.70.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.70.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.70.dist-info/RECORD,,