data-designer-engine 0.9.5__tar.gz → 0.9.6__tar.gz

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: data-designer-engine
-Version: 0.9.5
+Version: 0.9.6
 Summary: Generation engine for DataDesigner synthetic data generation
 License-Expression: Apache-2.0
 Classifier: Development Status :: 4 - Beta
@@ -16,7 +16,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
 Requires-Dist: anyascii<1,>=0.3.3
 Requires-Dist: asciichartpy<2,>=1.5.25
-Requires-Dist: data-designer-config==0.9.5
+Requires-Dist: data-designer-config==0.9.6
 Requires-Dist: duckdb<2,>=1.5.0
 Requires-Dist: faker<21,>=20.1.0
 Requires-Dist: fsspec<2027,>=2026.6.0
@@ -29,7 +29,7 @@ Requires-Dist: jsonpath-rust-bindings<2,>=1.0
 Requires-Dist: jsonschema<5,>=4.0.0
 Requires-Dist: lxml<7,>=6.1.1
 Requires-Dist: marko<3,>=2.1.2
-Requires-Dist: mcp<2,>=1.29.0
+Requires-Dist: mcp<2,>=1.30.0
 Requires-Dist: networkx<4,>=3.0
 Requires-Dist: numpy<3,>=1.23.5
 Requires-Dist: pandas<4,>=2.3.3

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/pyproject.toml

@@ -48,7 +48,7 @@ dependencies = [
     "jsonschema>=4.0.0,<5",
     "lxml>=6.1.1,<7", # 6.1.1 fixes CVE-2026-49825
     "marko>=2.1.2,<3",
-    "mcp>=1.29.0,<2", # 1.29.0 fixes MCP security advisories
+    "mcp>=1.30.0,<2", # 1.30.0 fixes CVE-2026-59951
     "networkx>=3.0,<4",
     "numpy>=1.23.5,<3",
     "pandas>=2.3.3,<4",

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/dataset_builders/dataset_builder.py

@@ -328,6 +328,7 @@ class DatasetBuilder:
         if self._post_generation_processed_resume_result(resume, num_records) is not None:
             return self.artifact_storage.final_dataset_path
 
+        self.artifact_storage.create_dataset_directory(resume=resume)
         self._write_builder_config()
 
         # Set media storage mode based on parameters

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/models/clients/factory.py

@@ -12,8 +12,8 @@ from data_designer.engine.models.clients.adapters.openai_compatible import OpenA
 from data_designer.engine.models.clients.base import ModelClient
 from data_designer.engine.models.clients.model_request_executor import ModelRequestExecutor
 from data_designer.engine.models.clients.retry import RetryConfig
-from data_designer.engine.models.errors import FormattedLLMErrorMessage
 from data_designer.engine.models.request_admission.controller import RequestAdmissionController
+from data_designer.engine.models.utils import FormattedLLMErrorMessage
 from data_designer.engine.observability import RequestAdmissionEventSink
 from data_designer.engine.secret_resolver import SecretResolver
 

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/models/errors.py

@@ -8,11 +8,9 @@ from collections.abc import Callable
 from functools import wraps
 from typing import Any, NoReturn
 
-from pydantic import BaseModel
-
 from data_designer.engine.errors import DataDesignerError
 from data_designer.engine.models.clients.errors import ProviderError, ProviderErrorKind, SyncClientUnavailableError
-from data_designer.engine.models.utils import GenerationTruncationReason
+from data_designer.engine.models.utils import FormattedLLMErrorMessage, GenerationTruncationReason
 
 logger = logging.getLogger(__name__)
 
@@ -152,25 +150,6 @@ RETRYABLE_MODEL_ERRORS: tuple[type[Exception], ...] = (
 )
 
 
-class FormattedLLMErrorMessage(BaseModel):
-    cause: str
-    solution: str
-    provider_message: str | None = None
-
-    def __str__(self) -> str:
-        lines = ["  |----------"]
-        if self.provider_message is not None:
-            lines.append(f"  | Provider message: {self.provider_message}")
-        lines.append(f"  | Cause: {self.cause}")
-        lines.extend(
-            [
-                f"  | Solution: {self.solution}",
-                "  |----------",
-            ]
-        )
-        return "\n".join(lines)
-
-
 def _attach_provider_message(
     formatted_message: FormattedLLMErrorMessage,
     exception: ProviderError,

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/models/recipes/response_recipes.py

@@ -82,8 +82,9 @@ class StructuredResponseRecipe(ResponseRecipe[dict]):
             pruning (bool): If `True`, then any extra fields in the returned
                 JSON object will be removed. Otherwise, they are retained,
                 which could raise validation errors. Default=True
-            no_extra_properties (bool): If `True`, then validation will fail
-                if extra properties are encountered in the returned JSON response.
+            no_extra_properties (bool): If `True`, forbid undeclared record fields,
+                pruning them when `pruning=True`. Explicit `additionalProperties`
+                settings, including dictionary value schemas, are preserved.
                 Default=True.
         """
         super().__init__(**kwargs)

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/models/utils.py

@@ -7,6 +7,8 @@ from dataclasses import dataclass, field
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Literal
 
+from pydantic import BaseModel
+
 if TYPE_CHECKING:
     from data_designer.engine.models.clients.types import ChatCompletionResponse
 
@@ -60,6 +62,27 @@ def merge_conversation_truncation_reason(
     return current or accumulated
 
 
+class FormattedLLMErrorMessage(BaseModel):
+    """User-facing LLM error text: the cause, a suggested solution, and the provider message if any."""
+
+    cause: str
+    solution: str
+    provider_message: str | None = None
+
+    def __str__(self) -> str:
+        lines = ["  |----------"]
+        if self.provider_message is not None:
+            lines.append(f"  | Provider message: {self.provider_message}")
+        lines.append(f"  | Cause: {self.cause}")
+        lines.extend(
+            [
+                f"  | Solution: {self.solution}",
+                "  |----------",
+            ]
+        )
+        return "\n".join(lines)
+
+
 @dataclass
 class ChatMessage:
     """A chat message in an LLM conversation.

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/processing/gsonschema/schema_transformers.py

@@ -32,14 +32,15 @@ def _is_bare_dictionary_schema(schema_part: Any) -> bool:
 
 
 def forbid_additional_properties(schema: JSONSchemaT) -> JSONSchemaT:
-    """Transform the provided schema into one which forbids additional properties.
+    """Forbid undeclared record fields while preserving explicit dictionary schemas.
 
     Args:
         schema (JSONSchemaT): A JSONSchema to transform.
 
     Returns:
         JSONSchemaT: A new JSONSchema matching the provided one, but
-            with `additionalProperties: False` set everywhere.
+            with `additionalProperties: False` added to records that do not
+            declare it. Explicit settings and bare dictionaries are preserved.
     """
     new_schema = deepcopy(schema)
 
@@ -50,7 +51,7 @@ def forbid_additional_properties(schema: JSONSchemaT) -> JSONSchemaT:
                 ## dictionary. In those cases, the implication is that _all_ dictionaries
                 ## are valid, so we should not forbid extra properties in that case.
                 allow_additional_properties = _is_bare_dictionary_schema(schema_part)
-                schema_part["additionalProperties"] = allow_additional_properties
+                schema_part.setdefault("additionalProperties", allow_additional_properties)
 
             # Traverse into nested schemas.
             for key, value in schema_part.items():
@@ -68,7 +69,7 @@ def forbid_additional_properties(schema: JSONSchemaT) -> JSONSchemaT:
                     if isinstance(value, list):
                         for item in value:
                             _enforce(item)
-                elif key in ("not", "if", "then", "else"):
+                elif key in ("not", "if", "then", "else", "additionalProperties"):
                     if isinstance(value, dict):
                         _enforce(value)
                 elif key == "$defs":

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/processing/gsonschema/validators.py

@@ -6,9 +6,10 @@ from __future__ import annotations
 import functools
 import logging
 import re
+from collections.abc import Iterator
 from copy import deepcopy
 from decimal import ROUND_HALF_UP, Decimal
-from typing import Any, overload
+from typing import Any, Literal, overload
 
 import data_designer.lazy_heavy_imports as lazy
 from data_designer.engine.processing.gsonschema.exceptions import JSONSchemaValidationError
@@ -25,32 +26,37 @@ logger = logging.getLogger(__name__)
 
 
 def prune_additional_properties(
-    _, allow_additional_properties: bool, instance: DataObjectT, schema: JSONSchemaT
-) -> None:
-    """A JSONSchemaValidtor extension function to prune additional properties.
+    validator: Any, allow_additional_properties: bool | JSONSchemaT, instance: DataObjectT, schema: JSONSchemaT
+) -> Iterator[Any]:
+    """Prune forbidden properties and validate explicitly allowed dictionary values.
 
     Operates on an individual schema in-place.
 
     Args:
-        allow_additional_properties (bool): The value of the `additionalProperties`
+        validator: The active JSON Schema validator.
+        allow_additional_properties: The value of the `additionalProperties`
             field for this schema.
         instance (DataObjectT): The data object being validated.
         schema (JSONSchemaT): The schema for this object.
 
-    Returns:
-        Nothing (in place)
+    Yields:
+        Validation errors for schema-valued additional properties.
     """
-    # Only act if the instance is a dict.
-    if not isinstance(instance, dict) or allow_additional_properties:
+    if allow_additional_properties is not False:
+        yield from lazy.jsonschema.Draft202012Validator.VALIDATORS["additionalProperties"](
+            validator, allow_additional_properties, instance, schema
+        )
+        return
+    if not isinstance(instance, dict):
         return
 
-    # Allowed keys are those defined in the schema's "properties".
+    # Properties matched by a pattern are also declared fields.
     allowed = schema.get("properties", {}).keys()
 
     # Iterate over a copy of keys so we can modify the dict in place.
     n_removed = 0
     for key in list(instance.keys()):
-        if key not in allowed:
+        if key not in allowed and not any(re.search(pattern, key) for pattern in schema.get("patternProperties", {})):
             instance.pop(key)
             n_removed += 1
             logger.info(f"Unspecified property removed from data object: {key}.")
@@ -59,25 +65,82 @@ def prune_additional_properties(
         logger.info(f"{n_removed} unspecified properties removed from data object.")
 
 
+def _validate_alternatives_with_pruning(
+    validator: Any,
+    alternatives: list[JSONSchemaT],
+    instance: DataObjectT,
+    keyword: Literal["anyOf", "oneOf"],
+) -> Iterator[Any]:
+    """Prefer unchanged matches, falling back to isolated pruning candidates."""
+    errors = []
+    unpruned_matches: list[DataObjectT] = []
+    pruned_matches: list[DataObjectT] = []
+    for index, subschema in enumerate(alternatives):
+        candidate = deepcopy(instance)
+        candidate_errors = list(validator.descend(candidate, subschema, schema_path=index))
+        if candidate_errors:
+            errors.extend(candidate_errors)
+        elif candidate == instance:
+            unpruned_matches.append(candidate)
+            if keyword == "anyOf":
+                return
+        else:
+            pruned_matches.append(candidate)
+
+    matches = unpruned_matches or pruned_matches
+    if not matches:
+        yield lazy.jsonschema.ValidationError(
+            f"{instance!r} is not valid under any of the given schemas", context=errors
+        )
+        return
+    if keyword == "oneOf" and len(matches) > 1:
+        yield lazy.jsonschema.ValidationError(f"{instance!r} is valid under more than one of the given schemas")
+        return
+
+    if keyword == "oneOf":
+        # An explicit dialect selects the stock validator while evolve retains reference scope.
+        strict_validator = validator.evolve(
+            schema={"$schema": _get_default_validator().META_SCHEMA["$id"], "oneOf": alternatives}
+        )
+        final_errors = list(strict_validator.iter_errors(matches[0]))
+        if final_errors:
+            yield from final_errors
+            return
+
+    if isinstance(instance, dict):
+        instance.clear()
+        instance.update(matches[0])
+    elif isinstance(instance, list):
+        instance[:] = matches[0]
+
+
+def _validate_any_of_with_pruning(
+    validator: Any, any_of: list[JSONSchemaT], instance: DataObjectT, schema: JSONSchemaT
+) -> Iterator[Any]:
+    yield from _validate_alternatives_with_pruning(validator, any_of, instance, "anyOf")
+
+
 def _validate_one_of_with_discriminator(
     validator: Any, one_of: list[JSONSchemaT], instance: DataObjectT, schema: JSONSchemaT
-) -> Any:
+) -> Iterator[Any]:
     """Validate a oneOf using the discriminator to select the correct variant.
 
     Standard oneOf tries all variants, which combined with in-place pruning
     can corrupt the instance (pruning from a failed variant removes properties
     needed by the correct variant). When a discriminator is present, this
-    validator selects the matching variant directly.
+    validator selects the matching variant directly. Without a discriminator,
+    each variant is validated on an independent copy. Matches that need no
+    pruning take precedence over matches that remove fields.
     """
     discriminator = schema.get("discriminator")
     if not discriminator or not isinstance(discriminator, dict) or not isinstance(instance, dict):
-        yield from lazy.jsonschema.Draft202012Validator.VALIDATORS["oneOf"](validator, one_of, instance, schema)
+        yield from _validate_alternatives_with_pruning(validator, one_of, instance, "oneOf")
         return
 
     prop_name = discriminator.get("propertyName")
     mapping = discriminator.get("mapping", {})
     if not prop_name or prop_name not in instance or not mapping:
-        yield from lazy.jsonschema.Draft202012Validator.VALIDATORS["oneOf"](validator, one_of, instance, schema)
+        yield from _validate_alternatives_with_pruning(validator, one_of, instance, "oneOf")
         return
 
     matched_ref = mapping.get(str(instance[prop_name]))
@@ -100,9 +163,10 @@ def extend_jsonschema_validator_with_pruning(validator):
     extra, unspecified fiends when `additionalProperties: False` is
     set in the validating schema.
 
-    When a oneOf has a discriminator, the discriminator is used to select
-    the correct variant directly, preventing in-place pruning from
-    corrupting the instance during failed variant checks.
+    Alternatives are checked on independent copies so failed candidates cannot
+    prune fields from later candidates. Unchanged matches take precedence over
+    pruned matches. Selected oneOf results must match exactly one alternative
+    without further pruning. Discriminated oneOf schemas select the correct variant directly.
 
     Args:
         validator (Type[jsonschema.Validator): A validator class
@@ -116,6 +180,7 @@ def extend_jsonschema_validator_with_pruning(validator):
         validator,
         {
             "additionalProperties": prune_additional_properties,
+            "anyOf": _validate_any_of_with_pruning,
             "oneOf": _validate_one_of_with_discriminator,
         },
     )
@@ -220,9 +285,9 @@ def validate(
             Default: `False`.
         no_extra_properties (bool): If set to `True`, then
             `additionalProperties: False` is set on all the schema
-            and all of its sub-schemas. This operation overrides any
-            existing settings of `additionalProperties` within the
-            schema. Default: `False`.
+            and its record sub-schemas where no explicit setting exists.
+            Declared dictionary schemas and explicit `additionalProperties`
+            settings are preserved. Default: `False`.
 
     Raises:
         JSONSchemaValidationError: This exception raised in the

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/resources/managed_dataset_generator.py

@@ -23,7 +23,13 @@ class ManagedDatasetGenerator:
     ) -> pd.DataFrame:
         parameters = []
         uri = self._person_reader.get_dataset_uri(self._locale)
-        query = f"select * from '{uri}'"
+        source = f"'{uri}'"
+        if self._locale == "de_DE":
+            source = (
+                "(select * replace (case sex when 'Weiblich' then 'Female' "
+                f"when 'Männlich' then 'Male' else sex end as sex) from {source})"
+            )
+        query = f"select * from {source}"
         if evidence:
             where_conditions = []
             for column, values in evidence.items():

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/sampling_gen/entities/dataset_based_person_fields.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 REQUIRED_FIELDS = {"first_name", "last_name", "age", "locale"}
 
 PII_FIELDS = [
-    # Universal demographic fields (present in every managed locale)
+    # Shared demographic fields (availability varies by locale)
     "uuid",
     "first_name",
     "middle_name",
@@ -43,8 +43,9 @@ PII_FIELDS = [
     "national_id",
     # en_US + en_SG
     "ethnic_background",
-    # en_SG-specific
+    # Shared by en_SG, en_GB, and de_DE
     "industry",
+    # en_SG-specific
     "preferred_english_name",
     # fr_FR-specific
     "first_name_heritage",
@@ -67,6 +68,19 @@ PII_FIELDS = [
     "military_status",
     "smoking_status",
     "waist_status",
+    # en_GB-specific
+    "ethnicity",
+    "country_of_birth",
+    "disability",
+    # de_DE-specific
+    "migration_background",
+    "employment_status",
+    "job_position",
+    "occupation_kldb",
+    "last_occupation",
+    "last_occupation_kldb",
+    "kreis_code",
+    "nationality",
     # pt_BR-specific
     "race",
     # India locales (en_IN, hi_Deva_IN, hi_Latn_IN)
@@ -75,7 +89,7 @@ PII_FIELDS = [
     "second_language",
     "third_language",
     "zone",
-    # Shared across India locales, en_SG, and pt_BR
+    # Shared across India locales, en_SG, pt_BR, en_GB, and de_DE
     "religion",
 ]
 

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/sampling_gen/generator.py

@@ -71,11 +71,6 @@ class DatasetGenerator:
             "people_gen_resource": create_people_gen_resource(self.schema, person_generator_loader),
         }
 
-    def _round_if_needed(self, column: ConditionalDataColumn, df: pd.DataFrame) -> pd.DataFrame:
-        if hasattr(column.params, "decimal_places") and column.params.decimal_places is not None:
-            df[column.name] = df[column.name].round(column.params.decimal_places)
-        return df
-
     def _run_rejection_sampling(self, df: pd.DataFrame, column: ConditionalDataColumn) -> pd.DataFrame:
         name = column.name
         num_iterations = 0
@@ -88,8 +83,17 @@ class DatasetGenerator:
                     condition,
                     jinja_rendering_engine=self._jinja_rendering_engine,
                 ).select_index(df[needs_samples])
+                if index.empty:
+                    continue
                 src = column.get_sampler(condition, **self._shared_sampler_kwargs)
                 df = src.inject_data_column(df, name, index)
+                decimal_places = getattr(src.params, "decimal_places", None)
+                if decimal_places is not None:
+                    samples = df.loc[index, name]
+                    # Preserve integer conversion before precision rounding, but round before converting to strings.
+                    if column.convert_to == "int":
+                        samples = src.preproc(samples, column.convert_to)
+                    df.loc[index, name] = samples.round(decimal_places)
 
             df[name] = column.get_default_sampler(**self._shared_sampler_kwargs).preproc(df[name], column.convert_to)
 
@@ -121,6 +125,5 @@ class DatasetGenerator:
             dataset[column.name] = column.get_default_sampler(**self._shared_sampler_kwargs).postproc(
                 dataset[column.name], column.convert_to
             )
-            dataset = self._round_if_needed(column, dataset)
 
         return dataset[self.schema.column_names]

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/storage/artifact_storage.py

@@ -11,6 +11,7 @@ from datetime import datetime
 from functools import cached_property
 from pathlib import Path
 from typing import TYPE_CHECKING
+from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, PrivateAttr, field_validator, model_validator
 
@@ -165,6 +166,31 @@ class ArtifactStorage(BaseModel):
         self._media_storage.base_path = self.base_dataset_path
         self._media_storage.images_dir = self.base_dataset_path / images_subdir
 
+    def create_dataset_directory(self, *, resume: ResumeMode) -> None:
+        """Exclusively claim a fresh dataset directory, or reuse it when resuming."""
+        if resume != ResumeMode.NEVER:
+            self.mkdir_if_needed(self.base_dataset_path)
+            return
+
+        dataset_path = self.base_dataset_path
+        while True:
+            try:
+                dataset_path.mkdir(exist_ok=False)
+            except FileExistsError:
+                dataset_path = self.artifact_path / (
+                    f"{self.dataset_name}_{datetime.now().strftime('%m-%d-%Y_%H%M%S')}_{uuid4().hex[:8]}"
+                )
+            except OSError as exc:
+                raise ArtifactStorageError(f"Cannot create dataset directory {str(dataset_path)!r}: {exc}") from exc
+            else:
+                break
+
+        if dataset_path != self.base_dataset_path:
+            logger.info(f"📂 Dataset directory already claimed. This run will be saved to {str(dataset_path)!r}.")
+        # Pydantic 2.9 does not support assigning to cached properties.
+        self.__dict__["resolved_dataset_name"] = dataset_path.name
+        self.refresh_media_storage_path()
+
     @staticmethod
     def mkdir_if_needed(path: Path | str) -> Path:
         """Create the directory if it does not exist."""

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/src/data_designer/engine/validators/python.py

@@ -42,8 +42,8 @@ TYPE_FROM_SYMBOL = {
     "PLE": "error",
     "PLR": "refactor",
     "PLW": "warning",
-    "SyntaxError": "fatal",
 }
+SYNTAX_ERROR_CODES = {"invalid-syntax", "E999", "SyntaxError"}
 
 PYTHON_MESSAGES_FIELD = "python_linter_messages"
 RECORD_ID_COLUMN_NAME = "internal_code_record_id"
@@ -215,18 +215,20 @@ class PythonValidator(BaseValidator):
 
         for diagnostic in diagnostics:
             filename = diagnostic["filename"]
-            code = diagnostic["code"]
+            code = diagnostic.get("code")
             location = diagnostic["location"]
             message = diagnostic["message"]
 
-            # Extract alphabetic prefix from code for type mapping
-            alpha_prefix = "".join(c for c in code if c.isalpha())
-            error_type = TYPE_FROM_SYMBOL.get(alpha_prefix, "warning")
+            if code is None or code in SYNTAX_ERROR_CODES:
+                error_type = "fatal"
+            else:
+                alpha_prefix = "".join(c for c in code if c.isalpha())
+                error_type = TYPE_FROM_SYMBOL.get(alpha_prefix, "warning")
 
             processed[Path(filename).stem].add(
                 PythonLinterMessage(
                     type=error_type,
-                    symbol=code,
+                    symbol=str(code),
                     line=location["row"],
                     column=location["column"],
                     message=message,

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/tests/engine/column_generators/utils/test_prompt_renderer.py

@@ -1,9 +1,12 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 from unittest.mock import Mock, patch
 
 import pytest
+from pydantic import BaseModel, JsonValue
 
 from data_designer.config.column_configs import (
     LLMCodeColumnConfig,
@@ -34,6 +37,24 @@ def test_prompt_renderer_prompt_type():
     assert issubclass(PromptType, str)
 
 
+class DictionaryOutput(BaseModel):
+    fields: dict[str, int]
+    metadata: dict[str, JsonValue]
+
+
+@pytest.mark.parametrize("use_pydantic", [False, True], ids=["json-schema", "pydantic"])
+def test_create_response_recipe_preserves_structured_dictionary_schema(use_pydantic: bool) -> None:
+    config = LLMStructuredColumnConfig(
+        name="test_column",
+        prompt="Test prompt",
+        model_alias="test_model",
+        output_format=DictionaryOutput if use_pydantic else DictionaryOutput.model_json_schema(),
+    )
+    example = DictionaryOutput(fields={"alpha": 1}, metadata={"nested": {"values": [1, "two", None]}})
+    recipe = create_response_recipe(config)
+    assert recipe.parse(example.model_dump_json()) == example.model_dump()
+
+
 @pytest.mark.parametrize(
     "config_class,expected_recipe_class",
     [

{data_designer_engine-0.9.5 → data_designer_engine-0.9.6}/tests/engine/models/clients/test_factory.py

@@ -130,8 +130,18 @@ def test_unknown_provider_type_raises_data_designer_error(
         inference_parameters=ChatCompletionInferenceParams(),
         provider="custom-provider",
     )
-    with pytest.raises(DataDesignerError, match="Provider type 'custom'.*is not supported"):
+    with pytest.raises(DataDesignerError) as exc_info:
         create_model_client(config, secret_resolver, registry)
+    assert type(exc_info.value) is DataDesignerError
+    assert str(exc_info.value) == "\n".join(
+        [
+            "  |----------",
+            "  | Cause: Provider type 'custom' for provider 'custom-provider' is not supported.",
+            "  | Solution: Change provider_type to one of 'openai', 'anthropic' in your model provider config. "
+            'Most OpenAI-compatible endpoints (vLLM, TGI, NIM, etc.) work with provider_type="openai".',
+            "  |----------",
+        ]
+    )
 
 
 def test_openai_provider_type_case_insensitive(