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

{lm_deluge-0.0.73/src/lm_deluge.egg-info → lm_deluge-0.0.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.73
+Version: 0.0.75
 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.75}/pyproject.toml

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

@@ -12,6 +12,10 @@ from lm_deluge.prompt import (
 from lm_deluge.request_context import RequestContext
 from lm_deluge.tool import MCPServer, Tool
 from lm_deluge.usage import Usage
+from lm_deluge.util.schema import (
+    prepare_output_schema,
+    transform_schema_for_anthropic,
+)
 
 from ..models import APIModel
 from .base import APIRequestBase, APIResponse
@@ -84,12 +88,42 @@ 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:
+            base_schema = prepare_output_schema(context.output_schema)
+
+            # Apply Anthropic-specific transformations (move unsupported constraints to description)
+            transformed_schema = transform_schema_for_anthropic(base_schema)
+
+            _add_beta(base_headers, "structured-outputs-2025-11-13")
+            request_json["output_format"] = {
+                "type": "json_schema",
+                "schema": transformed_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.75}/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,11 @@ 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.75}/src/lm_deluge/api_requests/openai.py

@@ -9,6 +9,10 @@ from aiohttp import ClientResponse
 from lm_deluge.request_context import RequestContext
 from lm_deluge.tool import MCPServer, Tool
 from lm_deluge.warnings import maybe_warn
+from lm_deluge.util.schema import (
+    prepare_output_schema,
+    transform_schema_for_openai,
+)
 
 from ..config import SamplingParams
 from ..models import APIModel
@@ -83,17 +87,48 @@ 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:
+            base_schema = prepare_output_schema(context.output_schema)
+
+            # Apply OpenAI-specific transformations (currently passthrough with copy)
+            transformed_schema = transform_schema_for_openai(base_schema)
+
+            request_json["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "response",
+                    "schema": transformed_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 +332,27 @@ 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:
+            base_schema = prepare_output_schema(context.output_schema)
+
+            # Apply OpenAI-specific transformations (currently passthrough with copy)
+            transformed_schema = transform_schema_for_openai(base_schema)
+
+            request_json["text"] = {
+                "format": {
+                    "type": "json_schema",
+                    "name": "response",
+                    "schema": transformed_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 +360,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 +374,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.75}/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: type[BaseModel] | 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: type[BaseModel] | 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: type[BaseModel] | 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: type[BaseModel] | 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: type[BaseModel] | 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: type[BaseModel] | 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.75}/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.75}/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.75}/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.75}/src/lm_deluge/request_context.py

@@ -1,11 +1,14 @@
 from dataclasses import dataclass, field
 from functools import cached_property
-from typing import Any, Callable
+from typing import Any, Callable, TYPE_CHECKING
 
 from .config import SamplingParams
 from .prompt import CachePattern, Conversation
 from .tracker import StatusTracker
 
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
 
 @dataclass
 class RequestContext:
@@ -32,6 +35,7 @@ class RequestContext:
 
     # Optional features
     tools: list | None = None
+    output_schema: "type[BaseModel] | dict | None" = None
     cache: CachePattern | None = None
     use_responses_api: bool = False
     background: bool = False
@@ -66,6 +70,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.75}/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.75/src/lm_deluge/util/schema.py

@@ -0,0 +1,412 @@
+"""Schema transformation utilities for structured outputs.
+
+This module provides utilities for transforming Pydantic models and JSON schemas
+to be compatible with provider-specific structured output requirements (OpenAI, Anthropic).
+
+Key functions:
+- to_strict_json_schema: Convert Pydantic model to strict JSON schema
+- transform_schema_for_openai: Apply OpenAI-specific transformations
+- transform_schema_for_anthropic: Apply Anthropic-specific transformations
+"""
+
+from __future__ import annotations
+
+import copy
+import inspect
+from typing import Any, TypeGuard, TYPE_CHECKING, Type
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
+try:
+    import pydantic
+    from pydantic import BaseModel as _BaseModel
+except ImportError:
+    pydantic = None
+    _BaseModel = None  # type: ignore
+
+
+def is_pydantic_model(obj: Any) -> bool:
+    """Check if an object is a Pydantic model class."""
+    if pydantic is None or _BaseModel is None:
+        return False
+    return inspect.isclass(obj) and issubclass(obj, _BaseModel)
+
+
+def is_dict(obj: object) -> TypeGuard[dict[str, object]]:
+    """Type guard for dictionaries."""
+    return isinstance(obj, dict)
+
+
+def has_more_than_n_keys(obj: dict[str, object], n: int) -> bool:
+    """Check if a dictionary has more than n keys."""
+    i = 0
+    for _ in obj.keys():
+        i += 1
+        if i > n:
+            return True
+    return False
+
+
+def resolve_ref(*, root: dict[str, object], ref: str) -> object:
+    """Resolve a JSON Schema $ref pointer.
+
+    Args:
+        root: The root schema object
+        ref: The $ref string (e.g., "#/$defs/MyType")
+
+    Returns:
+        The resolved schema object
+
+    Raises:
+        ValueError: If the $ref format is invalid or cannot be resolved
+    """
+    if not ref.startswith("#/"):
+        raise ValueError(f"Unexpected $ref format {ref!r}; Does not start with #/")
+
+    path = ref[2:].split("/")
+    resolved = root
+    for key in path:
+        value = resolved[key]
+        if not is_dict(value):
+            raise ValueError(
+                f"Encountered non-dictionary entry while resolving {ref} - {resolved}"
+            )
+        resolved = value
+
+    return resolved
+
+
+def to_strict_json_schema(model: Type["BaseModel"]) -> dict[str, Any]:
+    """Convert a Pydantic model to a strict JSON schema.
+
+    This function extracts the JSON schema from a Pydantic model and ensures
+    it conforms to the strict mode requirements for structured outputs.
+
+    Args:
+        model: A Pydantic BaseModel class
+
+    Returns:
+        A JSON schema dict that conforms to strict mode requirements
+
+    Raises:
+        TypeError: If the model is not a Pydantic BaseModel
+        ImportError: If pydantic is not installed
+    """
+    if pydantic is None or _BaseModel is None:
+        raise ImportError(
+            "pydantic is required for Pydantic model support. "
+            "Install it with: pip install pydantic"
+        )
+
+    if not is_pydantic_model(model):
+        raise TypeError(
+            f"Expected a Pydantic BaseModel class, got {type(model).__name__}"
+        )
+
+    schema = model.model_json_schema()
+    return _ensure_strict_json_schema(schema, path=(), root=schema)
+
+
+def prepare_output_schema(
+    schema_obj: Type["BaseModel"] | dict[str, Any],
+) -> dict[str, Any]:
+    """Normalize a user-provided schema into strict JSON schema form.
+
+    Args:
+        schema_obj: Either a Pydantic BaseModel subclass or a JSON schema dict.
+
+    Returns:
+        A strict JSON schema suitable for provider-specific transformation.
+
+    Notes:
+        Dict schemas are deep-copied before normalization so the caller's
+        original object is left untouched.
+    """
+
+    if is_pydantic_model(schema_obj):
+        return to_strict_json_schema(schema_obj)  # type: ignore[arg-type]
+
+    if is_dict(schema_obj):
+        schema_copy = copy.deepcopy(schema_obj)
+        return _ensure_strict_json_schema(
+            schema_copy,
+            path=(),
+            root=schema_copy,
+        )
+
+    raise TypeError(
+        "output_schema must be a Pydantic BaseModel subclass or a JSON schema dict"
+    )
+
+
+def _ensure_strict_json_schema(
+    json_schema: object,
+    *,
+    path: tuple[str, ...],
+    root: dict[str, object],
+) -> dict[str, Any]:
+    """Recursively ensure a JSON schema conforms to strict mode requirements.
+
+    This function:
+    - Adds additionalProperties: false to all objects
+    - Makes all properties required
+    - Removes unsupported constraints and adds them to descriptions
+    - Expands $refs that are mixed with other properties
+    - Processes $defs, anyOf, allOf, etc.
+
+    Args:
+        json_schema: The schema to transform
+        path: Current path in the schema (for error messages)
+        root: The root schema (for resolving $refs)
+
+    Returns:
+        The transformed schema
+    """
+    if not is_dict(json_schema):
+        raise TypeError(f"Expected {json_schema} to be a dictionary; path={path}")
+
+    # Process $defs recursively
+    defs = json_schema.get("$defs")
+    if is_dict(defs):
+        for def_name, def_schema in defs.items():
+            _ensure_strict_json_schema(
+                def_schema, path=(*path, "$defs", def_name), root=root
+            )
+
+    # Process definitions recursively
+    definitions = json_schema.get("definitions")
+    if is_dict(definitions):
+        for definition_name, definition_schema in definitions.items():
+            _ensure_strict_json_schema(
+                definition_schema,
+                path=(*path, "definitions", definition_name),
+                root=root,
+            )
+
+    typ = json_schema.get("type")
+
+    # Object types - add additionalProperties: false and make all fields required
+    if typ == "object" and "additionalProperties" not in json_schema:
+        json_schema["additionalProperties"] = False
+
+    properties = json_schema.get("properties")
+    if is_dict(properties):
+        # Make all properties required
+        json_schema["required"] = list(properties.keys())
+
+        # Process each property recursively
+        json_schema["properties"] = {
+            key: _ensure_strict_json_schema(
+                prop_schema, path=(*path, "properties", key), root=root
+            )
+            for key, prop_schema in properties.items()
+        }
+
+    # Arrays - process items schema
+    items = json_schema.get("items")
+    if is_dict(items):
+        json_schema["items"] = _ensure_strict_json_schema(
+            items, path=(*path, "items"), root=root
+        )
+
+    # Unions - process each variant
+    any_of = json_schema.get("anyOf")
+    if isinstance(any_of, list):
+        json_schema["anyOf"] = [
+            _ensure_strict_json_schema(
+                variant, path=(*path, "anyOf", str(i)), root=root
+            )
+            for i, variant in enumerate(any_of)
+        ]
+
+    # Intersections - process each entry
+    all_of = json_schema.get("allOf")
+    if isinstance(all_of, list):
+        if len(all_of) == 1:
+            # Flatten single-element allOf
+            json_schema.update(
+                _ensure_strict_json_schema(
+                    all_of[0], path=(*path, "allOf", "0"), root=root
+                )
+            )
+            json_schema.pop("allOf")
+        else:
+            json_schema["allOf"] = [
+                _ensure_strict_json_schema(
+                    entry, path=(*path, "allOf", str(i)), root=root
+                )
+                for i, entry in enumerate(all_of)
+            ]
+
+    # Remove None defaults (redundant with nullable)
+    if "default" in json_schema and json_schema["default"] is None:
+        json_schema.pop("default")
+
+    # Expand $refs that are mixed with other properties
+    ref = json_schema.get("$ref")
+    if ref and has_more_than_n_keys(json_schema, 1):
+        if not isinstance(ref, str):
+            raise ValueError(f"Received non-string $ref - {ref}")
+
+        resolved = resolve_ref(root=root, ref=ref)
+        if not is_dict(resolved):
+            raise ValueError(
+                f"Expected `$ref: {ref}` to resolve to a dictionary but got {resolved}"
+            )
+
+        # Properties from json_schema take priority over $ref
+        json_schema.update({**resolved, **json_schema})
+        json_schema.pop("$ref")
+
+        # Re-process the expanded schema
+        return _ensure_strict_json_schema(json_schema, path=path, root=root)
+
+    return json_schema
+
+
+def _move_constraints_to_description(
+    json_schema: dict[str, Any],
+    constraint_keys: list[str],
+) -> dict[str, Any]:
+    """Move unsupported constraints to the description field.
+
+    This helps the model follow constraints even when they can't be enforced
+    by the grammar.
+
+    Args:
+        json_schema: The schema to modify
+        constraint_keys: List of constraint keys to move to description
+
+    Returns:
+        The modified schema
+    """
+    constraints_found = {}
+
+    for key in constraint_keys:
+        if key in json_schema:
+            constraints_found[key] = json_schema.pop(key)
+
+    if constraints_found:
+        description = json_schema.get("description", "")
+        constraint_str = ", ".join(
+            f"{key}: {value}" for key, value in constraints_found.items()
+        )
+
+        if description:
+            json_schema["description"] = f"{description}\n\n{{{constraint_str}}}"
+        else:
+            json_schema["description"] = f"{{{constraint_str}}}"
+
+    return json_schema
+
+
+def transform_schema_for_openai(schema: dict[str, Any]) -> dict[str, Any]:
+    """Return a deep copy of the schema for OpenAI requests.
+
+    OpenAI Structured Outputs currently support the standard constraints we
+    rely on (min/max length, numeric bounds, etc.), so we intentionally leave
+    the schema untouched apart from copying it to prevent downstream mutation.
+    """
+
+    return copy.deepcopy(schema)
+
+
+def _transform_schema_recursive_anthropic(
+    json_schema: dict[str, Any],
+    root: dict[str, Any],
+) -> dict[str, Any]:
+    """Recursively strip unsupported constraints for Anthropic."""
+    if not is_dict(json_schema):
+        return json_schema
+
+    # Process $defs
+    if "$defs" in json_schema and is_dict(json_schema["$defs"]):
+        for def_name, def_schema in json_schema["$defs"].items():
+            if is_dict(def_schema):
+                _transform_schema_recursive_anthropic(def_schema, root)
+
+    # Process definitions
+    if "definitions" in json_schema and is_dict(json_schema["definitions"]):
+        for def_name, def_schema in json_schema["definitions"].items():
+            if is_dict(def_schema):
+                _transform_schema_recursive_anthropic(def_schema, root)
+
+    typ = json_schema.get("type")
+
+    # Handle unsupported constraints based on type
+    if typ == "string":
+        _move_constraints_to_description(
+            json_schema,
+            ["minLength", "maxLength", "pattern"],
+        )
+    elif typ in ("number", "integer"):
+        _move_constraints_to_description(
+            json_schema,
+            [
+                "minimum",
+                "maximum",
+                "exclusiveMinimum",
+                "exclusiveMaximum",
+                "multipleOf",
+            ],
+        )
+    elif typ == "array":
+        _move_constraints_to_description(
+            json_schema,
+            [
+                "minItems",
+                "maxItems",
+            ],
+        )
+
+    # Recursively process nested schemas
+    if "properties" in json_schema and is_dict(json_schema["properties"]):
+        for prop_name, prop_schema in json_schema["properties"].items():
+            if is_dict(prop_schema):
+                _transform_schema_recursive_anthropic(prop_schema, root)
+
+    if "items" in json_schema and is_dict(json_schema["items"]):
+        _transform_schema_recursive_anthropic(json_schema["items"], root)
+
+    if "anyOf" in json_schema and isinstance(json_schema["anyOf"], list):
+        for variant in json_schema["anyOf"]:
+            if is_dict(variant):
+                _transform_schema_recursive_anthropic(variant, root)
+
+    if "allOf" in json_schema and isinstance(json_schema["allOf"], list):
+        for entry in json_schema["allOf"]:
+            if is_dict(entry):
+                _transform_schema_recursive_anthropic(entry, root)
+
+    return json_schema
+
+
+def transform_schema_for_anthropic(schema: dict[str, Any]) -> dict[str, Any]:
+    """Transform a JSON schema for Anthropic's structured output requirements."""
+
+    schema_copy = copy.deepcopy(schema)
+    return _transform_schema_recursive_anthropic(schema_copy, schema_copy)
+
+
+def get_json_schema(obj: Type["BaseModel"] | dict[str, Any]) -> dict[str, Any]:
+    """Get JSON schema from a Pydantic model or dict.
+
+    This is a convenience function that handles both Pydantic models
+    and raw dictionaries.
+
+    Args:
+        obj: Either a Pydantic BaseModel class or a dict
+
+    Returns:
+        The JSON schema dict
+    """
+    if is_pydantic_model(obj):
+        # Type narrowing: if is_pydantic_model returns True, obj must have model_json_schema
+        return obj.model_json_schema()  # type: ignore
+    elif is_dict(obj):
+        return obj  # type: ignore
+    else:
+        raise TypeError(
+            f"Expected Pydantic BaseModel or dict, got {type(obj).__name__}"
+        )

{lm_deluge-0.0.73 → lm_deluge-0.0.75/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.75
 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.75}/src/lm_deluge.egg-info/SOURCES.txt

@@ -74,6 +74,7 @@ src/lm_deluge/presets/meta.py
 src/lm_deluge/util/harmony.py
 src/lm_deluge/util/json.py
 src/lm_deluge/util/logprobs.py
+src/lm_deluge/util/schema.py
 src/lm_deluge/util/spatial.py
 src/lm_deluge/util/validation.py
 src/lm_deluge/util/xml.py