lm-deluge 0.0.72__tar.gz → 0.0.74__tar.gz

{lm_deluge-0.0.72/src/lm_deluge.egg-info → lm_deluge-0.0.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.72
+Version: 0.0.74
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "lm_deluge"
-version = "0.0.72"
+version = "0.0.74"
 authors = [{ name = "Benjamin Anderson", email = "ben@trytaylor.ai" }]
 description = "Python utility for using LLM API models."
 readme = "README.md"

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/src/lm_deluge/api_requests/anthropic.py

@@ -84,12 +84,37 @@ def _build_anthropic_request(
         if "temperature" in request_json and "top_p" in request_json:
             request_json.pop("top_p")
 
+    # Handle structured outputs (output_format)
+    if context.output_schema:
+        if model.supports_json:
+            _add_beta(base_headers, "structured-outputs-2025-11-13")
+            request_json["output_format"] = {
+                "type": "json_schema",
+                "schema": context.output_schema,
+            }
+        else:
+            print(
+                f"WARNING: Model {model.name} does not support structured outputs. Ignoring output_schema."
+            )
+    elif sampling_params.json_mode:
+        # Anthropic doesn't support basic json_mode without a schema
+        print(
+            "WARNING: Anthropic does not support basic json_mode without a schema. "
+            "Use output_schema parameter for structured JSON outputs."
+        )
+
+    # Add beta header for strict tools when enabled
+    if tools and sampling_params.strict_tools and model.supports_json:
+        _add_beta(base_headers, "structured-outputs-2025-11-13")
+
     if tools:
         mcp_servers = []
         tool_definitions = []
         for tool in tools:
             if isinstance(tool, Tool):
-                tool_definitions.append(tool.dump_for("anthropic"))
+                # Only use strict mode if model supports structured outputs
+                use_strict = sampling_params.strict_tools and model.supports_json
+                tool_definitions.append(tool.dump_for("anthropic", strict=use_strict))
             elif isinstance(tool, dict) and "url" in tool:
                 _add_beta(base_headers, "mcp-client-2025-04-04")
                 mcp_servers.append(tool)

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/src/lm_deluge/api_requests/bedrock.py

@@ -106,7 +106,8 @@ async def _build_anthropic_bedrock_request(
         tool_definitions = []
         for tool in tools:
             if isinstance(tool, Tool):
-                tool_definitions.append(tool.dump_for("anthropic"))
+                # Bedrock doesn't have the strict-mode betas Anthropic exposes yet
+                tool_definitions.append(tool.dump_for("anthropic", strict=False))
             elif isinstance(tool, dict):
                 tool_definitions.append(tool)
                 # add betas if needed
@@ -124,7 +125,9 @@ async def _build_anthropic_bedrock_request(
                 # Convert to individual tools locally (like OpenAI does)
                 individual_tools = await tool.to_tools()
                 for individual_tool in individual_tools:
-                    tool_definitions.append(individual_tool.dump_for("anthropic"))
+                    tool_definitions.append(
+                        individual_tool.dump_for("anthropic", strict=False)
+                    )
 
         # Add cache control to last tool if tools_only caching is specified
         if cache_pattern == "tools_only" and tool_definitions:
@@ -194,11 +197,13 @@ async def _build_openai_bedrock_request(
         request_tools = []
         for tool in tools:
             if isinstance(tool, Tool):
-                request_tools.append(tool.dump_for("openai-completions"))
+                request_tools.append(
+                    tool.dump_for("openai-completions", strict=False)
+                )
             elif isinstance(tool, MCPServer):
                 as_tools = await tool.to_tools()
                 request_tools.extend(
-                    [t.dump_for("openai-completions") for t in as_tools]
+                    [t.dump_for("openai-completions", strict=False) for t in as_tools]
                 )
         request_json["tools"] = request_tools
 

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/src/lm_deluge/api_requests/openai.py

@@ -67,10 +67,12 @@ async def _build_oa_chat_request(
                 effort = "minimal"
             else:
                 effort = "low"
-        if effort == "minimal" and "gpt-5" not in model.id:
-            print(
-                "WARNING: 'minimal' reasoning effort only allowed for gpt-5. setting to 'low'."
-            )
+        # GPT-5.1 models don't support 'minimal', they support 'none' instead
+        if effort == "minimal" and "gpt-5.1" in model.id:
+            maybe_warn("WARN_MINIMAL_TO_NONE", model_name=context.model_name)
+            effort = "none"
+        elif effort == "minimal" and "gpt-5" not in model.id:
+            maybe_warn("WARN_MINIMAL_TO_LOW", model_name=context.model_name)
             effort = "low"
         request_json["reasoning_effort"] = effort
     else:
@@ -81,17 +83,43 @@ async def _build_oa_chat_request(
         request_json["logprobs"] = True
         if sampling_params.top_logprobs is not None:
             request_json["top_logprobs"] = sampling_params.top_logprobs
-    if sampling_params.json_mode and model.supports_json:
+
+    # Handle structured outputs (output_schema takes precedence over json_mode)
+    if context.output_schema:
+        if model.supports_json:
+            request_json["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "response",
+                    "schema": context.output_schema,
+                    "strict": True,
+                },
+            }
+        else:
+            print(
+                f"WARNING: Model {model.name} does not support structured outputs. Ignoring output_schema."
+            )
+    elif sampling_params.json_mode and model.supports_json:
         request_json["response_format"] = {"type": "json_object"}
+
     if tools:
         request_tools = []
         for tool in tools:
             if isinstance(tool, Tool):
-                request_tools.append(tool.dump_for("openai-completions"))
+                request_tools.append(
+                    tool.dump_for(
+                        "openai-completions", strict=sampling_params.strict_tools
+                    )
+                )
             elif isinstance(tool, MCPServer):
                 as_tools = await tool.to_tools()
                 request_tools.extend(
-                    [t.dump_for("openai-completions") for t in as_tools]
+                    [
+                        t.dump_for(
+                            "openai-completions", strict=sampling_params.strict_tools
+                        )
+                        for t in as_tools
+                    ]
                 )
         request_json["tools"] = request_tools
     return request_json
@@ -271,23 +299,46 @@ async def _build_oa_responses_request(
         request_json["max_output_tokens"] = sampling_params.max_new_tokens
 
     if model.reasoning_model:
-        if sampling_params.reasoning_effort in [None, "none"]:
+        effort = sampling_params.reasoning_effort
+        if effort in [None, "none"]:
             # gemini models can switch reasoning off
             if "gemini" in model.id:
-                sampling_params.reasoning_effort = "none"
+                effort = "none"
             else:
-                sampling_params.reasoning_effort = "low"
+                effort = "low"
+        # GPT-5.1 models don't support 'minimal', they support 'none' instead
+        if effort == "minimal" and "gpt-5.1" in model.id:
+            maybe_warn("WARN_MINIMAL_TO_NONE", model_name=context.model_name)
+            effort = "none"
+        elif effort == "minimal" and "gpt-5" not in model.id:
+            maybe_warn("WARN_MINIMAL_TO_LOW", model_name=context.model_name)
+            effort = "low"
         request_json["temperature"] = 1.0
         request_json["top_p"] = 1.0
         request_json["reasoning"] = {
-            "effort": sampling_params.reasoning_effort,
+            "effort": effort,
             "summary": "auto",
         }
     else:
         if sampling_params.reasoning_effort:
             maybe_warn("WARN_REASONING_UNSUPPORTED", model_name=context.model_name)
 
-    if sampling_params.json_mode and model.supports_json:
+    # Handle structured outputs (output_schema takes precedence over json_mode)
+    if context.output_schema:
+        if model.supports_json:
+            request_json["text"] = {
+                "format": {
+                    "type": "json_schema",
+                    "name": "response",
+                    "schema": context.output_schema,
+                    "strict": True,
+                }
+            }
+        else:
+            print(
+                f"WARNING: Model {model.name} does not support structured outputs. Ignoring output_schema."
+            )
+    elif sampling_params.json_mode and model.supports_json:
         request_json["text"] = {"format": {"type": "json_object"}}
 
     # Handle tools
@@ -295,7 +346,9 @@ async def _build_oa_responses_request(
     # Add regular function tools
     for tool in tools or []:
         if isinstance(tool, Tool):
-            request_tools.append(tool.dump_for("openai-responses"))
+            request_tools.append(
+                tool.dump_for("openai-responses", strict=sampling_params.strict_tools)
+            )
         elif isinstance(tool, dict):
             # if computer use, make sure model supports it
             if tool["type"] == "computer_use_preview":
@@ -307,7 +360,14 @@ async def _build_oa_responses_request(
         elif isinstance(tool, MCPServer):
             if context.force_local_mcp:
                 as_tools = await tool.to_tools()
-                request_tools.extend([t.dump_for("openai-responses") for t in as_tools])
+                request_tools.extend(
+                    [
+                        t.dump_for(
+                            "openai-responses", strict=sampling_params.strict_tools
+                        )
+                        for t in as_tools
+                    ]
+                )
             else:
                 request_tools.append(tool.for_openai_responses())
 

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/src/lm_deluge/client.py

@@ -44,10 +44,14 @@ class _LLMClient(BaseModel):
     Keeps all validation, serialization, and existing functionality.
     """
 
-    _REASONING_SUFFIXES: ClassVar[dict[str, Literal["low", "medium", "high"]]] = {
+    _REASONING_SUFFIXES: ClassVar[
+        dict[str, Literal["low", "medium", "high", "minimal", "none"]]
+    ] = {
         "-low": "low",
         "-medium": "medium",
         "-high": "high",
+        "-minimal": "minimal",
+        "-none": "none",
     }
 
     model_names: str | list[str] = ["gpt-4.1-mini"]
@@ -149,9 +153,11 @@ class _LLMClient(BaseModel):
 
     def _normalize_model_names(
         self, models: list[str]
-    ) -> tuple[list[str], list[Literal["low", "medium", "high"] | None]]:
+    ) -> tuple[
+        list[str], list[Literal["low", "medium", "high", "minimal", "none"] | None]
+    ]:
         normalized: list[str] = []
-        efforts: list[Literal["low", "medium", "high"] | None] = []
+        efforts: list[Literal["low", "medium", "high", "minimal", "none"] | None] = []
 
         for name in models:
             base_name = self._preprocess_openrouter_model(name)
@@ -164,7 +170,10 @@ class _LLMClient(BaseModel):
         return normalized, efforts
 
     def _align_sampling_params(
-        self, per_model_efforts: list[Literal["low", "medium", "high"] | None]
+        self,
+        per_model_efforts: list[
+            Literal["low", "medium", "high", "minimal", "none"] | None
+        ],
     ) -> None:
         if len(per_model_efforts) < len(self.model_names):
             per_model_efforts = per_model_efforts + [None] * (
@@ -332,7 +341,7 @@ class _LLMClient(BaseModel):
     @classmethod
     def _strip_reasoning_suffix_if_registered(
         cls, model_name: str
-    ) -> tuple[str, Literal["low", "medium", "high"] | None]:
+    ) -> tuple[str, Literal["low", "medium", "high", "minimal", "none"] | None]:
         """Remove reasoning suffix only when the trimmed model already exists."""
         for suffix, effort in cls._REASONING_SUFFIXES.items():
             if model_name.endswith(suffix) and len(model_name) > len(suffix):
@@ -364,6 +373,15 @@ class _LLMClient(BaseModel):
             assert (
                 self.use_responses_api
             ), "background mode only allowed for responses api"
+
+        # codex models require responses api
+        for model_name in self.model_names:
+            if "codex" in model_name.lower() and not self.use_responses_api:
+                raise ValueError(
+                    f"Model '{model_name}' requires use_responses_api=True. "
+                    "Codex models are only available via the Responses API."
+                )
+
         # Auto-generate name if not provided
         if self.name is None:
             if len(self.model_names) == 1:
@@ -543,6 +561,7 @@ class _LLMClient(BaseModel):
         return_completions_only: Literal[True],
         show_progress: bool = ...,
         tools: list[Tool | dict | MCPServer] | None = ...,
+        output_schema: dict | None = ...,
         cache: CachePattern | None = ...,
         service_tier: Literal["auto", "default", "flex", "priority"] | None = ...,
     ) -> list[str | None]: ...
@@ -555,6 +574,7 @@ class _LLMClient(BaseModel):
         return_completions_only: Literal[False] = ...,
         show_progress: bool = ...,
         tools: list[Tool | dict | MCPServer] | None = ...,
+        output_schema: dict | None = ...,
         cache: CachePattern | None = ...,
         service_tier: Literal["auto", "default", "flex", "priority"] | None = ...,
     ) -> list[APIResponse]: ...
@@ -566,6 +586,7 @@ class _LLMClient(BaseModel):
         return_completions_only: bool = False,
         show_progress: bool = True,
         tools: list[Tool | dict | MCPServer] | None = None,
+        output_schema: dict | None = None,
         cache: CachePattern | None = None,
         service_tier: Literal["auto", "default", "flex", "priority"] | None = None,
     ) -> list[APIResponse] | list[str | None] | dict[str, int]:
@@ -594,6 +615,7 @@ class _LLMClient(BaseModel):
             task_id = self.start_nowait(
                 prompt,
                 tools=tools,
+                output_schema=output_schema,
                 cache=cache,
                 service_tier=service_tier,
             )
@@ -639,6 +661,7 @@ class _LLMClient(BaseModel):
         return_completions_only: bool = False,
         show_progress=True,
         tools: list[Tool | dict | MCPServer] | None = None,
+        output_schema: dict | None = None,
         cache: CachePattern | None = None,
     ):
         return asyncio.run(
@@ -647,6 +670,7 @@ class _LLMClient(BaseModel):
                 return_completions_only=return_completions_only,
                 show_progress=show_progress,
                 tools=tools,
+                output_schema=output_schema,
                 cache=cache,
             )
         )
@@ -670,6 +694,7 @@ class _LLMClient(BaseModel):
         prompt: Prompt,
         *,
         tools: list[Tool | dict | MCPServer] | None = None,
+        output_schema: dict | None = None,
         cache: CachePattern | None = None,
         service_tier: Literal["auto", "default", "flex", "priority"] | None = None,
     ) -> int:
@@ -688,6 +713,7 @@ class _LLMClient(BaseModel):
             request_timeout=self.request_timeout,
             status_tracker=tracker,
             tools=tools,
+            output_schema=output_schema,
             cache=cache,
             use_responses_api=self.use_responses_api,
             background=self.background,
@@ -705,11 +731,16 @@ class _LLMClient(BaseModel):
         prompt: Prompt,
         *,
         tools: list[Tool | dict | MCPServer] | None = None,
+        output_schema: dict | None = None,
         cache: CachePattern | None = None,
         service_tier: Literal["auto", "default", "flex", "priority"] | None = None,
     ) -> APIResponse:
         task_id = self.start_nowait(
-            prompt, tools=tools, cache=cache, service_tier=service_tier
+            prompt,
+            tools=tools,
+            output_schema=output_schema,
+            cache=cache,
+            service_tier=service_tier,
         )
         return await self.wait_for(task_id)
 

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/src/lm_deluge/config.py

@@ -7,10 +7,11 @@ class SamplingParams(BaseModel):
     temperature: float = 0.0
     top_p: float = 1.0
     json_mode: bool = False
-    max_new_tokens: int = 512
+    max_new_tokens: int = 2_048
     reasoning_effort: Literal["low", "medium", "high", "minimal", "none", None] = None
     logprobs: bool = False
     top_logprobs: int | None = None
+    strict_tools: bool = True
 
     def to_vllm(self):
         try:

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/src/lm_deluge/models/anthropic.py

@@ -27,7 +27,7 @@ ANTHROPIC_MODELS = {
         "name": "claude-sonnet-4-5-20250929",
         "api_base": "https://api.anthropic.com/v1",
         "api_key_env_var": "ANTHROPIC_API_KEY",
-        "supports_json": False,
+        "supports_json": True,
         "api_spec": "anthropic",
         "input_cost": 3.0,
         "cached_input_cost": 0.30,
@@ -39,7 +39,7 @@ ANTHROPIC_MODELS = {
         "name": "claude-opus-4-1-20250805",
         "api_base": "https://api.anthropic.com/v1",
         "api_key_env_var": "ANTHROPIC_API_KEY",
-        "supports_json": False,
+        "supports_json": True,
         "api_spec": "anthropic",
         "input_cost": 15.0,
         "cached_input_cost": 1.50,

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/src/lm_deluge/models/openai.py

@@ -10,6 +10,48 @@ OPENAI_MODELS = {
     #                ░███
     #                █████
     #               ░░░░░
+    "gpt-5.1": {
+        "id": "gpt-5.1",
+        "name": "gpt-5.1",
+        "api_base": "https://api.openai.com/v1",
+        "api_key_env_var": "OPENAI_API_KEY",
+        "supports_json": False,
+        "supports_logprobs": True,
+        "supports_responses": True,
+        "api_spec": "openai",
+        "input_cost": 1.25,
+        "cached_input_cost": 0.125,
+        "output_cost": 10.0,
+        "reasoning_model": True,
+    },
+    "gpt-5.1-codex": {
+        "id": "gpt-5.1-codex",
+        "name": "gpt-5.1-codex",
+        "api_base": "https://api.openai.com/v1",
+        "api_key_env_var": "OPENAI_API_KEY",
+        "supports_json": False,
+        "supports_logprobs": True,
+        "supports_responses": True,
+        "api_spec": "openai",
+        "input_cost": 1.25,
+        "cached_input_cost": 0.125,
+        "output_cost": 10.0,
+        "reasoning_model": True,
+    },
+    "gpt-5.1-codex-mini": {
+        "id": "gpt-5.1-codex-mini",
+        "name": "gpt-5.1-codex-mini",
+        "api_base": "https://api.openai.com/v1",
+        "api_key_env_var": "OPENAI_API_KEY",
+        "supports_json": False,
+        "supports_logprobs": True,
+        "supports_responses": True,
+        "api_spec": "openai",
+        "input_cost": 0.25,
+        "cached_input_cost": 0.025,
+        "output_cost": 2.0,
+        "reasoning_model": True,
+    },
     "gpt-5-codex": {
         "id": "gpt-5-codex",
         "name": "gpt-5-codex",

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/src/lm_deluge/prompt.py

@@ -1195,14 +1195,24 @@ class Conversation:
 
     @classmethod
     def from_unknown(
-        cls, messages: list[dict], *, system: str | list[dict] | None = None
+        cls, messages: list[dict] | dict, *, system: str | list[dict] | None = None
     ) -> tuple["Conversation", str]:
         """Attempt to convert provider-formatted messages without knowing the provider.
 
         Returns the parsed conversation together with the provider label that succeeded
-        ("openai" or "anthropic").
+        ("openai", "anthropic", or "log").
         """
 
+        # Check if input is in log format (output from to_log())
+        if isinstance(messages, dict) and "messages" in messages:
+            return cls.from_log(messages), "log"
+
+        # Ensure messages is a list for provider detection
+        if not isinstance(messages, list):
+            raise ValueError(
+                "messages must be a list of dicts or a dict with 'messages' key"
+            )
+
         def _detect_provider() -> str:
             has_openai_markers = False
             has_anthropic_markers = False

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/src/lm_deluge/request_context.py

@@ -32,6 +32,7 @@ class RequestContext:
 
     # Optional features
     tools: list | None = None
+    output_schema: dict | None = None
     cache: CachePattern | None = None
     use_responses_api: bool = False
     background: bool = False
@@ -66,6 +67,7 @@ class RequestContext:
             "results_arr": self.results_arr,
             "callback": self.callback,
             "tools": self.tools,
+            "output_schema": self.output_schema,
             "cache": self.cache,
             "use_responses_api": self.use_responses_api,
             "background": self.background,

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/src/lm_deluge/tool.py

@@ -713,17 +713,40 @@ class Tool(BaseModel):
         """just an alias for the above"""
         return self.for_openai_completions(strict=strict, **kwargs)
 
-    def for_openai_responses(self, **kwargs) -> dict[str, Any]:
+    def for_openai_responses(self, *, strict: bool = True, **kwargs) -> dict[str, Any]:
         if self.is_built_in:
             return {"type": self.type, **self.built_in_args, **kwargs}
-        return {
-            "type": "function",
-            "name": self.name,
-            "description": self.description,
-            "parameters": self._json_schema(include_additional_properties=True),
-        }
 
-    def for_anthropic(self, **kwargs) -> dict[str, Any]:
+        # Check if schema is compatible with strict mode
+        if strict and not self._is_strict_mode_compatible():
+            strict = False
+
+        if strict:
+            # For strict mode, remove defaults and make all parameters required
+            schema = self._json_schema(
+                include_additional_properties=True, remove_defaults=True
+            )
+            schema["required"] = list(
+                (self.parameters or {}).keys()
+            )  # All parameters required in strict mode
+
+            return {
+                "type": "function",
+                "name": self.name,
+                "description": self.description,
+                "parameters": schema,
+                "strict": True,
+            }
+        else:
+            # For non-strict mode, use the original required list
+            return {
+                "type": "function",
+                "name": self.name,
+                "description": self.description,
+                "parameters": self._json_schema(include_additional_properties=True),
+            }
+
+    def for_anthropic(self, *, strict: bool = True, **kwargs) -> dict[str, Any]:
         # built-in tools have "name", "type", maybe metadata
         if self.is_built_in:
             return {
@@ -732,11 +755,33 @@ class Tool(BaseModel):
                 **self.built_in_args,
                 **kwargs,
             }
-        return {
-            "name": self.name,
-            "description": self.description,
-            "input_schema": self._json_schema(),
-        }
+
+        # Check if schema is compatible with strict mode
+        if strict and not self._is_strict_mode_compatible():
+            strict = False
+
+        if strict:
+            # For strict mode, remove defaults and make all parameters required
+            schema = self._json_schema(
+                include_additional_properties=True, remove_defaults=True
+            )
+            schema["required"] = list(
+                (self.parameters or {}).keys()
+            )  # All parameters required in strict mode
+
+            return {
+                "name": self.name,
+                "description": self.description,
+                "input_schema": schema,
+                "strict": True,
+            }
+        else:
+            # For non-strict mode, use the original required list
+            return {
+                "name": self.name,
+                "description": self.description,
+                "input_schema": self._json_schema(),
+            }
 
     def for_google(self) -> dict[str, Any]:
         """
@@ -759,11 +804,11 @@ class Tool(BaseModel):
         **kw,
     ) -> dict[str, Any]:
         if provider == "openai-responses":
-            return self.for_openai_responses()
+            return self.for_openai_responses(**kw)
         if provider == "openai-completions":
             return self.for_openai_completions(**kw)
         if provider == "anthropic":
-            return self.for_anthropic()
+            return self.for_anthropic(**kw)
         if provider == "google":
             return self.for_google()
         raise ValueError(provider)

{lm_deluge-0.0.72 → lm_deluge-0.0.74}/src/lm_deluge/warnings.py

@@ -7,6 +7,8 @@ WARNINGS: dict[str, str] = {
     "WARN_REASONING_UNSUPPORTED": "Ignoring reasoning_effort param for non-reasoning model: {model_name}.",
     "WARN_CACHING_UNSUPPORTED": "Cache parameter '{cache_param}' is not supported, ignoring for {model_name}.",
     "WARN_LOGPROBS_UNSUPPORTED": "Ignoring logprobs param for non-logprobs model: {model_name}",
+    "WARN_MINIMAL_TO_LOW": "'minimal' reasoning effort only allowed for gpt-5 models. Setting to 'low' for {model_name}.",
+    "WARN_MINIMAL_TO_NONE": "GPT-5.1 models don't support 'minimal' reasoning effort. Converting to 'none' for {model_name}.",
 }
 
 

{lm_deluge-0.0.72 → lm_deluge-0.0.74/src/lm_deluge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.72
+Version: 0.0.74
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10