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

{lm_deluge-0.0.73/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.73
+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.73 → lm_deluge-0.0.74}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "lm_deluge"
-version = "0.0.73"
+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.73 → 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.73 → 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.73 → lm_deluge-0.0.74}/src/lm_deluge/api_requests/openai.py

@@ -83,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
@@ -297,7 +323,22 @@ async def _build_oa_responses_request(
         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
@@ -305,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":
@@ -317,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.73 → lm_deluge-0.0.74}/src/lm_deluge/client.py

@@ -561,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]: ...
@@ -573,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]: ...
@@ -584,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]:
@@ -612,6 +615,7 @@ class _LLMClient(BaseModel):
             task_id = self.start_nowait(
                 prompt,
                 tools=tools,
+                output_schema=output_schema,
                 cache=cache,
                 service_tier=service_tier,
             )
@@ -657,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(
@@ -665,6 +670,7 @@ class _LLMClient(BaseModel):
                 return_completions_only=return_completions_only,
                 show_progress=show_progress,
                 tools=tools,
+                output_schema=output_schema,
                 cache=cache,
             )
         )
@@ -688,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:
@@ -706,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,
@@ -723,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.73 → 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.73 → 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.73 → 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.73 → 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.73 → 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.73 → 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.73
+Version: 0.0.74
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10