langchain 1.0.5__py3-none-any.whl → 1.2.4__py3-none-any.whl

langchain/agents/structured_output.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import uuid
 from dataclasses import dataclass, is_dataclass
 from types import UnionType
@@ -74,7 +75,7 @@ class StructuredOutputValidationError(StructuredOutputError):
 
 
 def _parse_with_schema(
-    schema: type[SchemaT] | dict, schema_kind: SchemaKind, data: dict[str, Any]
+    schema: type[SchemaT] | dict[str, Any], schema_kind: SchemaKind, data: dict[str, Any]
 ) -> Any:
     """Parse data using for any supported schema type.
 
@@ -105,21 +106,21 @@ def _parse_with_schema(
 class _SchemaSpec(Generic[SchemaT]):
     """Describes a structured output schema."""
 
-    schema: type[SchemaT]
+    schema: type[SchemaT] | dict[str, Any]
     """The schema for the response, can be a Pydantic model, `dataclass`, `TypedDict`,
     or JSON schema dict."""
 
     name: str
     """Name of the schema, used for tool calling.
 
-    If not provided, the name will be the model name or `"response_format"` if it's a
-    JSON schema.
+    If not provided, the name will be the class name for models/dataclasses/TypedDicts,
+    or the `title` field for JSON schemas. Falls back to a generated name if unavailable.
     """
 
     description: str
     """Custom description of the schema.
 
-    If not provided, provided will use the model's docstring.
+    If not provided, will use the model's docstring.
     """
 
     schema_kind: SchemaKind
@@ -128,18 +129,28 @@ class _SchemaSpec(Generic[SchemaT]):
     json_schema: dict[str, Any]
     """JSON schema associated with the schema."""
 
-    strict: bool = False
+    strict: bool | None = None
     """Whether to enforce strict validation of the schema."""
 
     def __init__(
         self,
-        schema: type[SchemaT],
+        schema: type[SchemaT] | dict[str, Any],
         *,
         name: str | None = None,
         description: str | None = None,
-        strict: bool = False,
+        strict: bool | None = None,
     ) -> None:
-        """Initialize SchemaSpec with schema and optional parameters."""
+        """Initialize `SchemaSpec` with schema and optional parameters.
+
+        Args:
+            schema: Schema to describe.
+            name: Optional name for the schema.
+            description: Optional description for the schema.
+            strict: Whether to enforce strict validation of the schema.
+
+        Raises:
+            ValueError: If the schema type is unsupported.
+        """
         self.schema = schema
 
         if name:
@@ -181,10 +192,10 @@ class _SchemaSpec(Generic[SchemaT]):
 class ToolStrategy(Generic[SchemaT]):
     """Use a tool calling strategy for model responses."""
 
-    schema: type[SchemaT]
+    schema: type[SchemaT] | UnionType | dict[str, Any]
     """Schema for the tool calls."""
 
-    schema_specs: list[_SchemaSpec[SchemaT]]
+    schema_specs: list[_SchemaSpec[Any]]
     """Schema specs for the tool calls."""
 
     tool_message_content: str | None
@@ -207,7 +218,7 @@ class ToolStrategy(Generic[SchemaT]):
 
     def __init__(
         self,
-        schema: type[SchemaT],
+        schema: type[SchemaT] | UnionType | dict[str, Any],
         *,
         tool_message_content: str | None = None,
         handle_errors: bool
@@ -227,7 +238,7 @@ class ToolStrategy(Generic[SchemaT]):
 
         def _iter_variants(schema: Any) -> Iterable[Any]:
             """Yield leaf variants from Union and JSON Schema oneOf."""
-            if get_origin(schema) in (UnionType, Union):
+            if get_origin(schema) in {UnionType, Union}:
                 for arg in get_args(schema):
                     yield from _iter_variants(arg)
                 return
@@ -246,7 +257,7 @@ class ToolStrategy(Generic[SchemaT]):
 class ProviderStrategy(Generic[SchemaT]):
     """Use the model provider's native structured output method."""
 
-    schema: type[SchemaT]
+    schema: type[SchemaT] | dict[str, Any]
     """Schema for native mode."""
 
     schema_spec: _SchemaSpec[SchemaT]
@@ -254,22 +265,37 @@ class ProviderStrategy(Generic[SchemaT]):
 
     def __init__(
         self,
-        schema: type[SchemaT],
+        schema: type[SchemaT] | dict[str, Any],
+        *,
+        strict: bool | None = None,
     ) -> None:
-        """Initialize ProviderStrategy with schema."""
+        """Initialize ProviderStrategy with schema.
+
+        Args:
+            schema: Schema to enforce via the provider's native structured output.
+            strict: Whether to request strict provider-side schema enforcement.
+        """
         self.schema = schema
-        self.schema_spec = _SchemaSpec(schema)
+        self.schema_spec = _SchemaSpec(schema, strict=strict)
 
     def to_model_kwargs(self) -> dict[str, Any]:
-        """Convert to kwargs to bind to a model to force structured output."""
+        """Convert to kwargs to bind to a model to force structured output.
+
+        Returns:
+            The kwargs to bind to a model.
+        """
         # OpenAI:
         # - see https://platform.openai.com/docs/guides/structured-outputs
-        response_format = {
+        json_schema: dict[str, Any] = {
+            "name": self.schema_spec.name,
+            "schema": self.schema_spec.json_schema,
+        }
+        if self.schema_spec.strict:
+            json_schema["strict"] = True
+
+        response_format: dict[str, Any] = {
             "type": "json_schema",
-            "json_schema": {
-                "name": self.schema_spec.name,
-                "schema": self.schema_spec.json_schema,
-            },
+            "json_schema": json_schema,
         }
         return {"response_format": response_format}
 
@@ -283,7 +309,7 @@ class OutputToolBinding(Generic[SchemaT]):
     and the corresponding tool implementation used by the tools strategy.
     """
 
-    schema: type[SchemaT]
+    schema: type[SchemaT] | dict[str, Any]
     """The original schema provided for structured output
     (Pydantic model, dataclass, TypedDict, or JSON schema dict)."""
 
@@ -337,7 +363,7 @@ class ProviderStrategyBinding(Generic[SchemaT]):
     its type classification, and parsing logic for provider-enforced JSON.
     """
 
-    schema: type[SchemaT]
+    schema: type[SchemaT] | dict[str, Any]
     """The original schema provided for structured output
     (Pydantic model, `dataclass`, `TypedDict`, or JSON schema dict)."""
 
@@ -374,8 +400,6 @@ class ProviderStrategyBinding(Generic[SchemaT]):
         # Extract text content from AIMessage and parse as JSON
         raw_text = self._extract_text_content_from_message(response)
 
-        import json
-
         try:
             data = json.loads(raw_text)
         except Exception as e:
@@ -389,7 +413,8 @@ class ProviderStrategyBinding(Generic[SchemaT]):
         # Parse according to schema
         return _parse_with_schema(self.schema, self.schema_kind, data)
 
-    def _extract_text_content_from_message(self, message: AIMessage) -> str:
+    @staticmethod
+    def _extract_text_content_from_message(message: AIMessage) -> str:
         """Extract text content from an AIMessage.
 
         Args:
@@ -401,29 +426,27 @@ class ProviderStrategyBinding(Generic[SchemaT]):
         content = message.content
         if isinstance(content, str):
             return content
-        if isinstance(content, list):
-            parts: list[str] = []
-            for c in content:
-                if isinstance(c, dict):
-                    if c.get("type") == "text" and "text" in c:
-                        parts.append(str(c["text"]))
-                    elif "content" in c and isinstance(c["content"], str):
-                        parts.append(c["content"])
-                else:
-                    parts.append(str(c))
-            return "".join(parts)
-        return str(content)
+        parts: list[str] = []
+        for c in content:
+            if isinstance(c, dict):
+                if c.get("type") == "text" and "text" in c:
+                    parts.append(str(c["text"]))
+                elif "content" in c and isinstance(c["content"], str):
+                    parts.append(c["content"])
+            else:
+                parts.append(str(c))
+        return "".join(parts)
 
 
 class AutoStrategy(Generic[SchemaT]):
     """Automatically select the best strategy for structured output."""
 
-    schema: type[SchemaT]
+    schema: type[SchemaT] | dict[str, Any]
     """Schema for automatic mode."""
 
     def __init__(
         self,
-        schema: type[SchemaT],
+        schema: type[SchemaT] | dict[str, Any],
     ) -> None:
         """Initialize AutoStrategy with schema."""
         self.schema = schema

langchain/chat_models/__init__.py

@@ -1,10 +1,4 @@
-"""Entrypoint to using [chat models](https://docs.langchain.com/oss/python/langchain/models) in LangChain.
-
-!!! warning "Reference docs"
-    This page contains **reference documentation** for chat models. See
-    [the docs](https://docs.langchain.com/oss/python/langchain/models) for conceptual
-    guides, tutorials, and examples on using chat models.
-"""  # noqa: E501
+"""Entrypoint to using [chat models](https://docs.langchain.com/oss/python/langchain/models) in LangChain."""  # noqa: E501
 
 from langchain_core.language_models import BaseChatModel