swallowkit 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/core/scaffold/native-schema-generator.js

@@ -41,6 +41,8 @@ exports.getCSharpSchemaOptionPath = getCSharpSchemaOptionPath;
 exports.getPythonSchemaModelPath = getPythonSchemaModelPath;
 exports.getCSharpNativeGeneratorArgs = getCSharpNativeGeneratorArgs;
 exports.getPythonNativeGeneratorArgs = getPythonNativeGeneratorArgs;
+exports.toPythonRegex = toPythonRegex;
+exports.getPythonRegexWarnings = getPythonRegexWarnings;
 exports.validateNativeSchemaToolchain = validateNativeSchemaToolchain;
 exports.generateLanguageSchemaArtifacts = generateLanguageSchemaArtifacts;
 const fs = __importStar(require("fs"));
@@ -54,6 +56,8 @@ const python_uv_1 = require("../../utils/python-uv");
 exports.NSWAG_CONSOLECORE_VERSION = "14.7.1";
 exports.PYTHON_SCHEMA_CODEGEN_REQUIREMENT = "datamodel-code-generator>=0.44.0,<1.0.0";
 const PYTHON_OUTPUT_MODEL_TYPE = "pydantic_v2.BaseModel";
+// Preserve model syntax compatibility with existing deployments, not the tool's interpreter.
+const PYTHON_MODEL_SYNTAX_VERSION = "3.11";
 function getMachineAwareStdio() {
     return process.env.SWALLOWKIT_MACHINE_OUTPUT === "1" ? "pipe" : "inherit";
 }
@@ -160,8 +164,22 @@ function buildCSharpEnumMemberMap(values, enumType) {
 function csharpStringLiteral(value) {
     return JSON.stringify(value);
 }
-function isDateLikeField(field) {
-    return field.type === "date" || (field.type === "string" && field.name.toLowerCase().endsWith("at"));
+/** Date/time types are used only when the Zod schema declares them (z.iso.datetime(), z.iso.date(), z.date()). */
+function getCSharpScalarType(field) {
+    switch (field.type) {
+        case "string":
+            return field.format === "date-time" ? "DateTime" : field.format === "date" ? "DateOnly" : "string";
+        case "number":
+            return field.isInteger ? "long" : "double";
+        case "boolean":
+            return "bool";
+        case "date":
+            return "DateTime";
+        case "object":
+            return "Dictionary<string, object>";
+        default:
+            return "object";
+    }
 }
 function getCSharpSchemaModelPath(outputDir, modelName) {
     return path.join(outputDir, "src", "SwallowKitBackendModels", "Model", `${modelName}.cs`);
@@ -204,36 +222,24 @@ function getPythonNativeGeneratorArgs(specPath, outputPath) {
         "--output-model-type",
         PYTHON_OUTPUT_MODEL_TYPE,
         "--target-python-version",
-        "3.11",
+        PYTHON_MODEL_SYNTAX_VERSION,
         "--disable-timestamp",
         "--use-union-operator",
         "--collapse-root-models",
     ];
 }
 function getCSharpFieldBaseType(field) {
+    // Arrays first: arrays of nested models or enums are lists of the element type.
+    if (field.isArray) {
+        return `List<${getCSharpArrayElementType(field)}>`;
+    }
     if (field.isNestedSchema && field.nestedModelName) {
         return field.nestedModelName;
     }
     if (field.enumValues?.length) {
         return `${toPascalIdentifier(field.name)}Enum`;
     }
-    if (field.isArray) {
-        return `List<${getCSharpArrayElementType(field)}>`;
-    }
-    switch (field.type) {
-        case "string":
-            return isDateLikeField(field) ? "DateTime" : "string";
-        case "number":
-            return "decimal";
-        case "boolean":
-            return "bool";
-        case "date":
-            return "DateTime";
-        case "object":
-            return "Dictionary<string, object>";
-        default:
-            return "object";
-    }
+    return getCSharpScalarType(field);
 }
 function getCSharpArrayElementType(field) {
     if (field.isNestedSchema && field.nestedModelName) {
@@ -242,24 +248,11 @@ function getCSharpArrayElementType(field) {
     if (field.enumValues?.length) {
         return `${toPascalIdentifier(field.name)}Enum`;
     }
-    switch (field.type) {
-        case "string":
-            return isDateLikeField(field) ? "DateTime" : "string";
-        case "number":
-            return "decimal";
-        case "boolean":
-            return "bool";
-        case "date":
-            return "DateTime";
-        case "object":
-            return "Dictionary<string, object>";
-        default:
-            return "object";
-    }
+    return getCSharpScalarType(field);
 }
 function getCSharpPropertyType(field) {
     const baseType = getCSharpFieldBaseType(field);
-    return field.isOptional ? `${baseType}?` : baseType;
+    return field.isOptional || field.isNullable ? `${baseType}?` : baseType;
 }
 function getCSharpOptionType(field) {
     return `Option<${getCSharpPropertyType(field)}>`;
@@ -316,11 +309,96 @@ function buildCSharpEnumToJsonCases(field, members) {
         .map((member) => `            if (value == ${enumType}.${member.name})\n                return ${csharpStringLiteral(member.value)};`)
         .join("\n\n");
 }
+function csharpNumberLiteral(value) {
+    return Number.isInteger(value) ? `${value}` : `${value}d`;
+}
+function csharpRegexOptions(flags) {
+    const options = [
+        flags?.includes("i") ? "RegexOptions.IgnoreCase" : null,
+        flags?.includes("m") ? "RegexOptions.Multiline" : null,
+        flags?.includes("s") ? "RegexOptions.Singleline" : null,
+    ].filter(Boolean);
+    return options.length > 0 ? options.join(" | ") : "RegexOptions.None";
+}
+function isCSharpReferenceType(field) {
+    if (field.isArray || field.isNestedSchema || field.type === "object")
+        return true;
+    if (field.enumValues?.length)
+        return false;
+    return field.type === "string" && field.format !== "date-time" && field.format !== "date";
+}
+/**
+ * Translate Zod constraints into IValidatableObject checks. Regexes use search semantics like
+ * Zod's RegExp.test. String formats (email/uuid/url) and value-type presence stay with Zod.
+ */
+function buildCSharpValueChecks(field, accessor, member, optionalValue) {
+    const constraints = field.constraints ?? {};
+    const checks = [];
+    const add = (condition, message) => checks.push(`if (${condition})\n                yield return new ValidationResult(${csharpStringLiteral(message)}, new[] { ${member} });`);
+    if (field.isNestedSchema && field.nestedModelName) {
+        // Pattern variables in an if condition stay in scope for the enclosing block, so keep names unique.
+        const variable = `validated${toPascalIdentifier(field.name)}${accessor === "item" ? "Item" : ""}`;
+        checks.push(`if (${accessor} is IValidatableObject ${variable})\n                foreach (var ${variable}Result in ${variable}.Validate(new ValidationContext(${accessor})))\n                    yield return new ValidationResult(${variable}Result.ErrorMessage, ${variable}Result.MemberNames.Select(name => ${member} + "." + name).ToArray());`);
+        return checks;
+    }
+    if (field.enumValues?.length)
+        return checks;
+    if (field.type === "string" && field.format !== "date-time" && field.format !== "date") {
+        if (constraints.minLength !== undefined)
+            add(`${accessor} != null && ${accessor}.Length < ${constraints.minLength}`, `${field.name} must contain at least ${constraints.minLength} character(s).`);
+        if (constraints.maxLength !== undefined)
+            add(`${accessor} != null && ${accessor}.Length > ${constraints.maxLength}`, `${field.name} must contain at most ${constraints.maxLength} character(s).`);
+        if (constraints.pattern !== undefined) {
+            add(`${accessor} != null && !Regex.IsMatch(${accessor}, ${csharpStringLiteral(constraints.pattern)}, ${csharpRegexOptions(constraints.patternFlags)})`, `${field.name} must match /${constraints.pattern}/${constraints.patternFlags ?? ""}.`);
+        }
+    }
+    if (field.type === "number") {
+        const value = optionalValue ? `${accessor}.Value` : accessor;
+        const guard = optionalValue ? `${accessor}.HasValue && ` : "";
+        if (constraints.minimum !== undefined) {
+            add(`${guard}${value} ${constraints.exclusiveMinimum ? "<=" : "<"} ${csharpNumberLiteral(constraints.minimum)}`, `${field.name} must be ${constraints.exclusiveMinimum ? "greater than" : "greater than or equal to"} ${constraints.minimum}.`);
+        }
+        if (constraints.maximum !== undefined) {
+            add(`${guard}${value} ${constraints.exclusiveMaximum ? ">=" : ">"} ${csharpNumberLiteral(constraints.maximum)}`, `${field.name} must be ${constraints.exclusiveMaximum ? "less than" : "less than or equal to"} ${constraints.maximum}.`);
+        }
+    }
+    return checks;
+}
+function buildCSharpValidationBody(model) {
+    const blocks = [];
+    for (const field of model.fields) {
+        const propertyName = toPascalIdentifier(field.name);
+        const member = csharpStringLiteral(field.name);
+        const constraints = field.constraints ?? {};
+        // .nullable() fields accept null in Zod, so only non-nullable required references are rejected.
+        if (!field.isOptional && !field.isNullable && isCSharpReferenceType(field)) {
+            blocks.push(`if (${propertyName} is null)\n                yield return new ValidationResult(${csharpStringLiteral(`${field.name} is required.`)}, new[] { ${member} });`);
+        }
+        if (field.isArray) {
+            if (constraints.minItems !== undefined) {
+                blocks.push(`if (${propertyName} != null && ${propertyName}.Count < ${constraints.minItems})\n                yield return new ValidationResult(${csharpStringLiteral(`${field.name} must contain at least ${constraints.minItems} item(s).`)}, new[] { ${member} });`);
+            }
+            if (constraints.maxItems !== undefined) {
+                blocks.push(`if (${propertyName} != null && ${propertyName}.Count > ${constraints.maxItems})\n                yield return new ValidationResult(${csharpStringLiteral(`${field.name} must contain at most ${constraints.maxItems} item(s).`)}, new[] { ${member} });`);
+            }
+            const itemChecks = buildCSharpValueChecks({ ...field, isArray: false }, "item", `${member} + "[" + index + "]"`, false);
+            if (itemChecks.length > 0) {
+                blocks.push(`if (${propertyName} != null)\n            {\n                for (var index = 0; index < ${propertyName}.Count; index++)\n                {\n                    var item = ${propertyName}[index];\n${itemChecks.map((check) => `                    ${check.replace(/\n {16}/g, "\n                        ").replace(/\n {20}/g, "\n                            ")}`).join("\n")}\n                }\n            }`);
+            }
+            continue;
+        }
+        const optionalValue = (field.isOptional || field.isNullable === true) && !isCSharpReferenceType(field);
+        blocks.push(...buildCSharpValueChecks(field, propertyName, member, optionalValue));
+    }
+    return blocks.length > 0
+        ? blocks.map((block) => `            ${block}`).join("\n\n")
+        : "            yield break;";
+}
 function generateLegacyCompatibleCSharpModelSource(model) {
     const requiredFields = model.fields.filter((field) => !field.isOptional);
     const optionalFields = model.fields.filter((field) => field.isOptional);
     const constructorParams = [
-        ...requiredFields.map((field) => `${getCSharpFieldBaseType(field)} ${field.name}`),
+        ...requiredFields.map((field) => `${getCSharpPropertyType(field)} ${field.name}`),
         ...optionalFields.map((field) => `${getCSharpOptionType(field)} ${field.name} = default`),
     ].join(", ");
     const constructorAssignments = [
@@ -336,7 +414,7 @@ function generateLegacyCompatibleCSharpModelSource(model) {
         return `        /// <summary>
         /// Defines ${toPascalIdentifier(field.name)}
         /// </summary>
-        [JsonConverter(typeof(JsonStringEnumConverter))]
+        [JsonConverter(typeof(${enumType}JsonConverter))]
         public enum ${enumType}
         {
 ${buildCSharpEnumMembers(enumMembers)}
@@ -357,6 +435,22 @@ ${buildCSharpEnumFromStringCases(field, enumMembers, true)}
 ${buildCSharpEnumToJsonCases(field, enumMembers)}
 
             throw new NotImplementedException($"Value could not be handled: '{value}'");
+        }
+
+        /// <summary>
+        /// Reads and writes ${enumType} with the exact Zod enum values.
+        /// </summary>
+        public sealed class ${enumType}JsonConverter : JsonConverter<${enumType}>
+        {
+            public override ${enumType} Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+            {
+                var value = reader.GetString();
+                var parsed = value == null ? null : ${enumType}FromStringOrDefault(value);
+                return parsed ?? throw new JsonException($"Unsupported ${enumType} value: '{value}'");
+            }
+
+            public override void Write(Utf8JsonWriter writer, ${enumType} value, JsonSerializerOptions options)
+                => writer.WriteStringValue(${enumType}ToJsonValue(value));
         }`;
     })
         .join("\n\n");
@@ -381,7 +475,8 @@ ${buildCSharpEnumToJsonCases(field, enumMembers)}
         /// <summary>
         /// Gets or Sets ${propertyName}
         /// </summary>
-        [JsonPropertyName("${field.name}")]
+        [JsonPropertyName("${field.name}")]${field.isNullable ? "" : `
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]`}
         public ${propertyType} ${propertyName} { get { return this.${propertyName}Option; } set { this.${propertyName}Option = new(value); } }`;
     })
         .join("\n\n");
@@ -403,8 +498,11 @@ ${buildCSharpEnumToJsonCases(field, enumMembers)}
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using System.Linq;
 using System.Text;
+using System.Text.Json;
 using System.Text.Json.Serialization;
+using System.Text.RegularExpressions;
 using SwallowKitBackendModels.Client;
 
 namespace SwallowKitBackendModels.Model
@@ -414,12 +512,22 @@ namespace SwallowKitBackendModels.Model
     /// </summary>
     public partial class ${model.name} : IValidatableObject
     {
+        /// <summary>
+        /// Used by System.Text.Json. Optional values are marked as set only when present in the JSON.
+        /// </summary>
+#pragma warning disable CS8618
         [JsonConstructor]
+        public ${model.name}()
+        {
+            OnCreated();
+        }
+#pragma warning restore CS8618
+${constructorParams ? `
         public ${model.name}(${constructorParams})
         {
 ${constructorAssignments}
         }
-
+` : ""}
         partial void OnCreated();
 ${enumBlocks ? `\n\n${enumBlocks}` : ""}
 
@@ -436,24 +544,18 @@ ${toStringBody}
 
         IEnumerable<ValidationResult> IValidatableObject.Validate(ValidationContext validationContext)
         {
-            yield break;
+${buildCSharpValidationBody(model)}
         }
     }
 }
 `;
 }
-function getPythonTypeName(field) {
-    if (field.isNestedSchema && field.nestedModelName) {
-        return field.nestedModelName;
-    }
-    if (field.isArray) {
-        return `List[${getPythonArrayElementType(field)}]`;
-    }
+function getPythonScalarType(field) {
     switch (field.type) {
         case "string":
-            return isDateLikeField(field) ? "datetime" : "StrictStr";
+            return field.format === "date-time" ? "datetime" : field.format === "date" ? "date" : "StrictStr";
         case "number":
-            return "Union[StrictFloat, StrictInt]";
+            return field.isInteger ? "StrictInt" : "Union[StrictFloat, StrictInt]";
         case "boolean":
             return "StrictBool";
         case "date":
@@ -464,36 +566,128 @@ function getPythonTypeName(field) {
             return "Any";
     }
 }
+/** pydantic Field bounds for a scalar value (string length or numeric range). */
+function getPythonValueConstraintArgs(field) {
+    const constraints = field.constraints ?? {};
+    if (field.enumValues?.length || field.isNestedSchema)
+        return [];
+    const args = [];
+    if (field.type === "string" && field.format !== "date-time" && field.format !== "date") {
+        if (constraints.minLength !== undefined)
+            args.push(`min_length=${constraints.minLength}`);
+        if (constraints.maxLength !== undefined)
+            args.push(`max_length=${constraints.maxLength}`);
+    }
+    if (field.type === "number") {
+        if (constraints.minimum !== undefined)
+            args.push(`${constraints.exclusiveMinimum ? "gt" : "ge"}=${constraints.minimum}`);
+        if (constraints.maximum !== undefined)
+            args.push(`${constraints.exclusiveMaximum ? "lt" : "le"}=${constraints.maximum}`);
+    }
+    return args;
+}
 function getPythonArrayElementType(field) {
     if (field.isNestedSchema && field.nestedModelName) {
         return field.nestedModelName;
     }
-    switch (field.type) {
-        case "string":
-            return isDateLikeField(field) ? "datetime" : "StrictStr";
-        case "number":
-            return "Union[StrictFloat, StrictInt]";
-        case "boolean":
-            return "StrictBool";
-        case "date":
-            return "datetime";
-        case "object":
-            return "Dict[str, Any]";
-        default:
-            return "Any";
+    const elementType = getPythonScalarType(field);
+    const elementArgs = getPythonValueConstraintArgs(field);
+    return elementArgs.length > 0 ? `Annotated[${elementType}, Field(${elementArgs.join(", ")})]` : elementType;
+}
+function getPythonTypeName(field) {
+    if (field.isArray) {
+        return `List[${getPythonArrayElementType(field)}]`;
     }
+    if (field.isNestedSchema && field.nestedModelName) {
+        return field.nestedModelName;
+    }
+    return getPythonScalarType(field);
 }
 function buildPythonFieldDeclaration(field) {
     const pythonName = toSnakeCase(field.name);
     const typeName = field.isOptional ? `Optional[${getPythonTypeName(field)}]` : getPythonTypeName(field);
-    const aliasSuffix = pythonName !== field.name ? `, alias="${field.name}"` : "";
-    if (field.isOptional) {
-        return `${pythonName}: ${typeName} = Field(default=None${aliasSuffix})`;
-    }
-    if (aliasSuffix) {
-        return `${pythonName}: ${typeName} = Field(${aliasSuffix.slice(2)})`;
-    }
-    return `${pythonName}: ${typeName}`;
+    const fieldArgs = [
+        ...(field.isOptional ? ["default=None"] : []),
+        ...(pythonName !== field.name ? [`alias="${field.name}"`] : []),
+        ...(field.isArray
+            ? [
+                ...(field.constraints?.minItems !== undefined ? [`min_length=${field.constraints.minItems}`] : []),
+                ...(field.constraints?.maxItems !== undefined ? [`max_length=${field.constraints.maxItems}`] : []),
+            ]
+            : getPythonValueConstraintArgs(field)),
+    ];
+    return fieldArgs.length > 0
+        ? `${pythonName}: ${typeName} = Field(${fieldArgs.join(", ")})`
+        : `${pythonName}: ${typeName}`;
+}
+function buildPythonRegexFlags(flags) {
+    const values = [
+        flags?.includes("i") ? "re.IGNORECASE" : null,
+        flags?.includes("m") ? "re.MULTILINE" : null,
+        flags?.includes("s") ? "re.DOTALL" : null,
+    ].filter(Boolean);
+    return values.length > 0 ? values.join(" | ") : "0";
+}
+/**
+ * Translates a JavaScript regex (as used by Zod) to Python `re` syntax. Constructs Python cannot
+ * express identically are reported as unsupported so the validator is skipped instead of breaking imports.
+ */
+function toPythonRegex(pattern, flags = "") {
+    const unsupportedFlags = [...flags].filter((flag) => !"imsgu".includes(flag));
+    if (unsupportedFlags.length > 0)
+        return { unsupported: `flag(s) ${unsupportedFlags.join("")} have no Python equivalent` };
+    const checks = [
+        [/\\[pP]\{/, "Unicode property escapes (\\p{...})"],
+        [/\\u\{/, "code point escapes (\\u{...})"],
+        [/\\c[A-Za-z]/, "control escapes (\\cX)"],
+        [/\(\?<[=!]/, "lookbehind (JavaScript allows variable width; Python does not)"],
+        [/\[\^?\]/, "empty character classes ([] / [^])"],
+    ];
+    for (const [construct, label] of checks) {
+        if (construct.test(pattern))
+            return { unsupported: label };
+    }
+    return {
+        pattern: pattern
+            .replace(/\(\?<([A-Za-z_][A-Za-z0-9_]*)>/g, "(?P<$1>")
+            .replace(/\\k<([A-Za-z_][A-Za-z0-9_]*)>/g, "(?P=$1)"),
+    };
+}
+function pythonRegexFields(model) {
+    return model.fields
+        .filter((field) => field.type === "string" && !field.enumValues?.length && field.constraints?.pattern !== undefined)
+        .map((field) => ({ field, translation: toPythonRegex(field.constraints.pattern, field.constraints.patternFlags) }));
+}
+function getPythonRegexWarnings(model) {
+    return pythonRegexFields(model)
+        .filter((entry) => "unsupported" in entry.translation)
+        .map(({ field, translation }) => `python-regex-not-enforced: ${model.name}.${field.name} uses ${translation.unsupported}; the Python model does not enforce /${field.constraints.pattern}/. The BFF Zod schema still validates it.`);
+}
+/**
+ * Zod regex checks use RegExp.test (search), so validators use re.search instead of pydantic's anchored pattern.
+ * They run before type conversion so date/time strings are checked as the JSON text Zod sees; non-string
+ * values are left to the field's own type validation.
+ */
+function buildPythonPatternValidators(model) {
+    return pythonRegexFields(model)
+        .filter((entry) => "pattern" in entry.translation)
+        .map(({ field, translation }) => {
+        const pythonName = toSnakeCase(field.name);
+        const pattern = JSON.stringify(translation.pattern);
+        const flags = buildPythonRegexFlags(field.constraints.patternFlags);
+        const message = JSON.stringify(`${field.name} must match /${field.constraints.pattern}/${field.constraints.patternFlags ?? ""}`);
+        return `    @field_validator('${pythonName}', mode='before')
+    def ${pythonName}_validate_pattern(cls, value):
+        """Validates the Zod regex constraint"""
+        if value is None:
+            return value
+
+        for item in (value if isinstance(value, list) else [value]):
+            if isinstance(item, str) and not re.search(${pattern}, item, ${flags}):
+                raise ValueError(${message})
+        return value`;
+    })
+        .join("\n\n");
 }
 function buildPythonEnumValidators(model) {
     return model.fields
@@ -524,7 +718,7 @@ function buildPythonModelImports(model) {
 function generateLegacyCompatiblePythonModelSource(model) {
     const fieldDeclarations = model.fields.map((field) => `    ${buildPythonFieldDeclaration(field)}`).join("\n");
     const propertyNames = model.fields.map((field) => `"${field.name}"`).join(", ");
-    const validators = buildPythonEnumValidators(model);
+    const validators = [buildPythonEnumValidators(model), buildPythonPatternValidators(model)].filter(Boolean).join("\n\n");
     const dictAssignments = model.fields
         .map((field) => `            "${field.name}": obj.get("${field.name}")`)
         .join(",\n");
@@ -547,9 +741,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from datetime import datetime
+from datetime import date, datetime
 from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List, Optional, Set, Union
+from typing import Annotated, Any, ClassVar, Dict, List, Optional, Set, Union
 from typing_extensions import Self
 
 ${buildPythonModelImports(model)}class ${model.name}(BaseModel):
@@ -573,7 +767,7 @@ ${validators ? `\n\n${validators}` : ""}
 
     def to_json(self) -> str:
         """Returns the JSON representation of the model using alias"""
-        return json.dumps(self.to_dict())
+        return self.model_dump_json(by_alias=True, exclude_none=True)
 
     @classmethod
     def from_json(cls, json_str: str) -> Optional[Self]:
@@ -660,13 +854,8 @@ function ensurePythonCodegenProjectFiles(functionsRoot, session, sourceModel) {
     }
     return requirementsPath;
 }
-function getVirtualEnvPythonPath(venvDir) {
-    return process.platform === "win32"
-        ? path.join(venvDir, "Scripts", "python.exe")
-        : path.join(venvDir, "bin", "python");
-}
 async function ensureProjectLocalUvCommand(projectRoot) {
-    const uvEnv = (0, python_uv_1.buildProjectLocalUvEnv)(process.env, projectRoot);
+    const uvEnv = { ...process.env };
     const { localUvExecutable } = (0, python_uv_1.getProjectLocalUvPaths)(projectRoot);
     if (canRun("uv", ["--version"], projectRoot)) {
         return { command: "uv", env: uvEnv };
@@ -685,16 +874,9 @@ async function ensurePythonCodegenEnvironment(functionsRoot, requirementsPath) {
     const projectRoot = (0, python_uv_1.getPythonProjectRoot)(functionsRoot);
     const { command: uvCommand, env: uvEnv } = await ensureProjectLocalUvCommand(projectRoot);
     const venvDir = path.join(functionsRoot, ".codegen-venv");
-    const venvPython = getVirtualEnvPythonPath(venvDir);
-    if (!canRun(venvPython, ["--version"], functionsRoot, uvEnv)) {
-        const venvArgs = (0, python_uv_1.buildUvVenvArgs)(venvDir);
-        if (fs.existsSync(venvDir)) {
-            venvArgs.push("--clear");
-        }
-        await runCommand(uvCommand, venvArgs, functionsRoot, "Failed to create the Python schema code generation virtual environment.", uvEnv);
-    }
+    const venvPython = await (0, python_uv_1.ensureUvVirtualEnvironment)(uvCommand, venvDir, functionsRoot, uvEnv);
     if (!canRun(venvPython, ["-c", "import datamodel_code_generator"], functionsRoot, uvEnv)) {
-        await runCommand(uvCommand, (0, python_uv_1.buildUvPipInstallArgs)(venvPython, requirementsPath), functionsRoot, "Failed to install Python schema generation dependencies.", uvEnv);
+        await runCommand(uvCommand, (0, python_uv_1.buildUvPipInstallArgs)(venvPython, requirementsPath), functionsRoot, "Failed to install Python schema generation dependencies.", (0, python_uv_1.buildPythonCodegenInstallEnv)(uvEnv));
     }
     return venvPython;
 }
@@ -764,6 +946,10 @@ async function generatePythonSchemaArtifacts(models, outputDir, functionsRoot, s
     writeMergedPythonInitFile(path.join(packageRoot, "__init__.py"), buildGeneratedPythonPackageInitSource(models), session, sourceModel);
     writeMergedPythonInitFile(path.join(modelsRoot, "__init__.py"), buildGeneratedPythonModelsInitSource(models), session, sourceModel);
     for (const model of models) {
+        for (const warning of getPythonRegexWarnings(model)) {
+            session.addWarning(warning);
+            console.warn(`⚠️  ${warning}`);
+        }
         const modelPath = getPythonSchemaModelPath(outputDir, model.name);
         session.writeFile(modelPath, generateLegacyCompatiblePythonModelSource(model), {
             ownership: "managed",
@@ -788,11 +974,13 @@ async function generateLanguageSchemaArtifacts(models, rootModel, functionsDir,
     });
     console.log(planning ? `\ud83d\udccb Will create: ${specPath}` : `\u2705 Created: ${specPath}`);
     const outputDir = path.join(functionsRoot, "generated", backendLanguage === "csharp" ? "csharp-models" : "python-models");
+    // Inline z.object fields become named classes (e.g. ProbeItemNested) so their shape is preserved.
+    const nativeModels = (0, openapi_generator_1.expandInlineObjectModels)(models);
     if (backendLanguage === "csharp") {
-        await generateCSharpSchemaArtifacts(models, outputDir, functionsRoot, session, rootModel.name);
+        await generateCSharpSchemaArtifacts(nativeModels, outputDir, functionsRoot, session, rootModel.name);
     }
     else {
-        await generatePythonSchemaArtifacts(models, outputDir, functionsRoot, session, rootModel.name);
+        await generatePythonSchemaArtifacts(nativeModels, outputDir, functionsRoot, session, rootModel.name);
     }
     console.log(planning
         ? `\ud83d\udccb Will generate ${backendLanguage} schema assets: ${outputDir}`