qtype 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

qtype/application/__init__.py

@@ -3,10 +3,8 @@
 from __future__ import annotations
 
 from . import commons, converters
-from .facade import QTypeFacade
 
 __all__ = [
-    "QTypeFacade",
     "converters",
     "commons",
 ]

qtype/application/converters/tools_from_api.py

@@ -26,7 +26,7 @@ from qtype.dsl.model import (
     BearerTokenAuthProvider,
     CustomType,
     OAuth2AuthProvider,
-    ToolParameter,
+    Variable,
     VariableType,
 )
 
@@ -86,47 +86,53 @@ def _create_custom_type_from_schema(
     schema_name_map: dict[int, str],
 ) -> CustomType:
     """Create a CustomType from an Object schema."""
-    # Generate a unique ID for this schema-based type
-    type_id = None
+    # Use object id instead of hash(str()) to avoid recursion with circular refs
+    schema_id = id(schema)
+
+    # Check if we already have this type (prevents circular reference issues)
+    if schema_id in schema_name_map:
+        type_id = schema_name_map[schema_id]
+        if type_id in existing_custom_types:
+            return existing_custom_types[type_id]
 
-    schema_hash = hash(str(schema))
-    if schema_hash in schema_name_map:
-        type_id = schema_name_map[schema_hash]
+    # Generate a unique ID for this schema-based type
+    if schema.title:
+        # Use title if available, make it lowercase, alphanumeric, snake_case
+        base_id = schema.title.lower().replace(" ", "_").replace("-", "_")
+        # Remove non-alphanumeric characters except underscores
+        type_id = "schema_" + "".join(
+            c for c in base_id if c.isalnum() or c == "_"
+        )
     else:
-        # make a type id manually
-        if schema.title:
-            # Use title if available, make it lowercase, alphanumeric, snake_case
-            base_id = schema.title.lower().replace(" ", "_").replace("-", "_")
-            # Remove non-alphanumeric characters except underscores
-            type_id = "schema_" + "".join(
-                c for c in base_id if c.isalnum() or c == "_"
-            )
-        else:
-            # Fallback to hash if no title
-            type_id = f"schema_{hash(str(schema))}"
+        # Fallback to object id if no title
+        type_id = f"schema_{schema_id}"
 
-    # Check if we already have this type
+    # Check again with the generated type_id
     if type_id in existing_custom_types:
         return existing_custom_types[type_id]
 
-    # Create properties from the schema
-    properties = _schema_to_qtype_properties(
-        schema, existing_custom_types, schema_name_map
-    )
-
-    # Create the custom type
-    custom_type = CustomType(
+    # Create a placeholder to prevent infinite recursion
+    # This will be updated with properties below
+    placeholder = CustomType(
         id=type_id,
         description=schema.description
         or schema.title
         or "Generated from OpenAPI schema",
-        properties=properties,
+        properties={},  # Empty initially
     )
 
-    # Store it in the registry to prevent infinite recursion
-    existing_custom_types[type_id] = custom_type
+    # Store it BEFORE processing properties to break circular references
+    existing_custom_types[type_id] = placeholder
 
-    return custom_type
+    # Now process properties (which may reference back to this type)
+    properties = _schema_to_qtype_properties(
+        schema, existing_custom_types, schema_name_map
+    )
+
+    # Update the placeholder with actual properties
+    placeholder.properties = properties
+
+    return placeholder
 
 
 def _schema_to_qtype_type(
@@ -196,9 +202,9 @@ def create_tool_parameters_from_body(
     existing_custom_types: dict[str, CustomType],
     schema_name_map: dict[int, str],
     default_param_name: str,
-) -> dict[str, ToolParameter]:
+) -> list[Variable]:
     """
-    Convert an OpenAPI Response or RequestBody to a dictionary of ToolParameters.
+    Convert an OpenAPI Response or RequestBody to a list of Variables.
 
     If the body has only one content type with an Object schema, flatten its properties
     to individual parameters. Otherwise, create a single parameter with the body type.
@@ -210,18 +216,18 @@ def create_tool_parameters_from_body(
         default_param_name: Name to use for non-flattened parameter
 
     Returns:
-        Dictionary of parameter name to ToolParameter objects
+        List of Variable objects
     """
     # Check if we have content to analyze
     if not hasattr(oas, "content") or not oas.content:
-        return {}
+        return []
 
     content = oas.content[0]
     input_type = to_variable_type(
         content, existing_custom_types, schema_name_map
     )
 
-    # Convert CustomType to string ID for ToolParameter
+    # Convert CustomType to string ID for Variable
     input_type_value = (
         input_type.id if isinstance(input_type, CustomType) else input_type
     )
@@ -234,7 +240,7 @@ def create_tool_parameters_from_body(
         custom_type = existing_custom_types[input_type.id]
 
         # Flatten the custom type properties to individual parameters
-        flattened_parameters = {}
+        flattened_parameters = []
         for prop_name, prop_type_str in custom_type.properties.items():
             # Check if the property is optional (has '?' suffix)
             is_optional = prop_type_str.endswith("?")
@@ -242,8 +248,10 @@ def create_tool_parameters_from_body(
                 prop_type_str.rstrip("?") if is_optional else prop_type_str
             )
 
-            flattened_parameters[prop_name] = ToolParameter(
-                type=clean_type, optional=is_optional
+            flattened_parameters.append(
+                Variable.model_construct(
+                    id=prop_name, type=clean_type, optional=is_optional
+                )
             )
 
         # remove the type from existing_custom_types to avoid confusion
@@ -252,11 +260,11 @@ def create_tool_parameters_from_body(
         return flattened_parameters
 
     # If not flattening, create a single parameter (e.g., for simple types or arrays)
-    return {
-        default_param_name: ToolParameter(
-            type=input_type_value, optional=False
+    return [
+        Variable.model_construct(
+            id=default_param_name, type=input_type_value, optional=False
         )
-    }
+    ]
 
 
 def to_api_tool(
@@ -291,7 +299,7 @@ def to_api_tool(
     ).replace("\n", " ")
 
     # Process inputs from request body and parameters
-    inputs = {}
+    inputs = []
     if operation.request_body and operation.request_body.content:
         # Create input parameters from request body using the new function
         input_params = create_tool_parameters_from_body(
@@ -300,27 +308,31 @@ def to_api_tool(
             schema_name_map,
             default_param_name="request",
         )
-        inputs.update(input_params)
+        inputs.extend(input_params)
 
     # Add path and query parameters as inputs
-    parameters = {}
+    parameters = []
     for param in operation.parameters:
         if param.schema:
             param_type = _schema_to_qtype_type(
                 param.schema, existing_custom_types, schema_name_map
             )
-            # Convert to appropriate type for ToolParameter
+            # Convert to appropriate type for Variable
             param_type_value = (
                 param_type.id
                 if isinstance(param_type, CustomType)
                 else param_type
             )
-            parameters[param.name] = ToolParameter(
-                type=param_type_value, optional=not param.required
+            parameters.append(
+                Variable.model_construct(
+                    id=param.name,
+                    type=param_type_value,
+                    optional=not param.required,
+                )
             )
 
     # Process outputs from responses
-    outputs = {}
+    outputs = []
     # Find the success response (200-299 status codes) or default response
     success_response = next(
         (r for r in operation.responses if r.code and 200 <= r.code < 300),
@@ -333,9 +345,9 @@ def to_api_tool(
             success_response,
             existing_custom_types,
             schema_name_map,
-            default_param_name="response",
+            default_param_name=f"{tool_id}_response",
         )
-        outputs.update(output_params)
+        outputs.extend(output_params)
 
     return APITool(
         id=tool_id,
@@ -353,9 +365,6 @@ def to_api_tool(
 def to_authorization_provider(
     api_name: str, scheme_name: str, security: Security
 ) -> AuthProviderType:
-    if security.scheme is None:
-        raise ValueError("Security scheme is missing")
-
     match security.type:
         case SecurityType.API_KEY:
             return APIKeyAuthProvider(
@@ -364,6 +373,8 @@ def to_authorization_provider(
                 host=None,  # Will be set from base URL if available
             )
         case SecurityType.HTTP:
+            if security.scheme is None:
+                raise ValueError("HTTP security scheme is missing")
             if security.scheme == AuthenticationScheme.BEARER:
                 return BearerTokenAuthProvider(
                     id=f"{api_name}_{scheme_name}_{security.bearer_format or 'token'}",
@@ -452,11 +463,10 @@ def tools_from_api(
     existing_custom_types: dict[str, CustomType] = {}
     tools = []
 
-    # Create a mapping from schema hash to their names in the OpenAPI spec
-    # Note: We can't monkey-patch here since the openapi_parser duplicates instances in memory
-    # if they are $ref'd in the content
+    # Create a mapping from schema id to their names in the OpenAPI spec
+    # Use id() instead of hash(str()) to avoid infinite recursion with circular refs
     schema_name_map: dict[int, str] = {
-        hash(str(schema)): name.replace(" ", "-").replace("_", "-")
+        id(schema): name.replace(" ", "-").replace("_", "-")
         for name, schema in specification.schemas.items()
     }
 

qtype/application/converters/tools_from_module.py

@@ -10,7 +10,7 @@ from qtype.dsl.model import (
     CustomType,
     ListType,
     PythonFunctionTool,
-    ToolParameter,
+    Variable,
     VariableType,
 )
 
@@ -43,14 +43,19 @@ def tools_from_module(
                 f"No public functions found in module '{module_path}'"
             )
 
-        custom_types: dict[str, CustomType] = {}
+        # Registry of actual Pydantic classes for validation
+        custom_type_registry: dict[str, Type[BaseModel]] = {}
+        # CustomType instances for YAML output
+        custom_type_models: dict[str, CustomType] = {}
 
         # Create Tool instances from functions
         tools = [
-            _create_tool_from_function(func_name, func_info, custom_types)
+            _create_tool_from_function(
+                func_name, func_info, custom_type_registry, custom_type_models
+            )
             for func_name, func_info in functions.items()
         ]
-        return (tools, list(custom_types.values()))
+        return (tools, list(custom_type_models.values()))
     except ImportError as e:
         raise ImportError(f"Cannot import module '{module_path}': {e}") from e
 
@@ -116,7 +121,8 @@ def _get_module_functions(
 def _create_tool_from_function(
     func_name: str,
     func_info: dict[str, Any],
-    custom_types: dict[str, CustomType],
+    custom_type_registry: dict[str, Type[BaseModel]],
+    custom_type_models: dict[str, CustomType],
 ) -> PythonFunctionTool:
     """
     Convert function metadata into a Tool instance.
@@ -135,29 +141,38 @@ def _create_tool_from_function(
         else f"Function {func_name}"
     )
 
-    # Create input parameters from function parameters
-    inputs = {
-        p["name"]: ToolParameter(
-            type=_map_python_type_to_variable_type(p["type"], custom_types),
-            optional=p["default"] != inspect.Parameter.empty,
+    # Create input parameters as list of Variables
+    inputs = [
+        Variable.model_validate(
+            {
+                "id": p["name"],
+                "type": _map_python_type_to_variable_type(
+                    p["type"], custom_type_registry, custom_type_models
+                ),
+                "optional": p["default"] != inspect.Parameter.empty,
+            },
+            context={"custom_types": custom_type_registry},
         )
         for p in func_info["parameters"]
-    }
-
-    # # quick hack
-    # for k, v in inputs.items():
-    #     if inspect.isclass(v.type) and issubclass(v.type, BaseModel):
-    #         v.type = str(v.type.__name__)
+    ]
 
     # Create output parameter based on return type
     tool_id = func_info["module"] + "." + func_name
 
     output_type = _map_python_type_to_variable_type(
-        func_info["return_type"], custom_types
+        func_info["return_type"], custom_type_registry, custom_type_models
     )
 
-    outputs = {"result": ToolParameter(type=output_type, optional=False)}
-    # outputs['result'].type =
+    outputs = [
+        Variable.model_validate(
+            {
+                "id": f"{func_name}_result",
+                "type": output_type,
+                "optional": False,
+            },
+            context={"custom_types": custom_type_registry},
+        )
+    ]
 
     return PythonFunctionTool(
         id=tool_id,
@@ -172,7 +187,8 @@ def _create_tool_from_function(
 
 def _pydantic_to_custom_types(
     model_cls: Type[BaseModel],
-    custom_types: dict[str, CustomType],
+    custom_type_registry: dict[str, Type[BaseModel]],
+    custom_type_models: dict[str, CustomType],
 ) -> str:
     """
     Converts a Pydantic BaseModel class into a QType CustomType.
@@ -184,15 +200,20 @@ def _pydantic_to_custom_types(
 
     Args:
         model_cls: The Pydantic model class to convert.
+        custom_type_registry: Registry of actual Pydantic classes for validation
+        custom_type_models: Dictionary of CustomType models for YAML output
 
     Returns:
-        A dictionary mapping field names to their corresponding CustomType definitions.
+        The model name as a string type reference
     """
     properties = {}
     model_name = model_cls.__name__
-    if model_name in custom_types:
+    if model_name in custom_type_registry:
         return model_name  # Already processed
 
+    # Register the actual class for validation
+    custom_type_registry[model_name] = model_cls
+
     for field_name, field_info in model_cls.model_fields.items():
         # Use the annotation (the type hint) for the field
         field_type = field_info.annotation
@@ -202,22 +223,27 @@ def _pydantic_to_custom_types(
             )
         elif get_origin(field_type) is Union:
             # Assume the union means it's optional
+            # TODO: support proper unions
             field_type = [
                 t for t in get_args(field_type) if t is not type(None)
             ][0]
-            rv = _map_python_type_to_type_str(field_type, custom_types)
+            rv = _map_python_type_to_type_str(
+                field_type, custom_type_registry, custom_type_models
+            )
             properties[field_name] = f"{rv}?"
         elif get_origin(field_type) is list:
             inner_type = get_args(field_type)[0]
-            rv = _map_python_type_to_type_str(inner_type, custom_types)
+            rv = _map_python_type_to_type_str(
+                inner_type, custom_type_registry, custom_type_models
+            )
             properties[field_name] = f"list[{rv}]"
         else:
             properties[field_name] = _map_python_type_to_type_str(
-                field_type, custom_types
+                field_type, custom_type_registry, custom_type_models
             )
 
-    # Add the custom type to the list
-    custom_types[model_name] = CustomType(
+    # Add the CustomType model for YAML output
+    custom_type_models[model_name] = CustomType(
         id=model_name,
         properties=properties,
         description=model_cls.__doc__ or f"Custom type for {model_name}",
@@ -227,7 +253,8 @@ def _pydantic_to_custom_types(
 
 def _map_python_type_to_variable_type(
     python_type: Any,
-    custom_types: dict[str, CustomType],
+    custom_type_registry: dict[str, Type[BaseModel]],
+    custom_type_models: dict[str, CustomType],
 ) -> str | VariableType:
     """
     Map Python type annotations to QType VariableType.
@@ -248,7 +275,9 @@ def _map_python_type_to_variable_type(
             element_type_annotation = args[0]
             # Recursively map the element type
             element_type = _map_python_type_to_variable_type(
-                element_type_annotation, custom_types
+                element_type_annotation,
+                custom_type_registry,
+                custom_type_models,
             )
             # Support lists of both primitive types and custom types
             if isinstance(element_type, PrimitiveTypeEnum):
@@ -281,7 +310,9 @@ def _map_python_type_to_variable_type(
         return python_type.__name__
     elif inspect.isclass(python_type) and issubclass(python_type, BaseModel):
         # If it's a Pydantic model, create or retrieve its CustomType definition
-        return _pydantic_to_custom_types(python_type, custom_types)
+        return _pydantic_to_custom_types(
+            python_type, custom_type_registry, custom_type_models
+        )
     raise ValueError(
         f"Unsupported Python type '{python_type}' for VariableType mapping"
     )
@@ -289,9 +320,12 @@ def _map_python_type_to_variable_type(
 
 def _map_python_type_to_type_str(
     python_type: Any,
-    custom_types: dict[str, CustomType],
+    custom_type_registry: dict[str, Type[BaseModel]],
+    custom_type_models: dict[str, CustomType],
 ) -> str:
-    var_type = _map_python_type_to_variable_type(python_type, custom_types)
+    var_type = _map_python_type_to_variable_type(
+        python_type, custom_type_registry, custom_type_models
+    )
     if isinstance(var_type, PrimitiveTypeEnum):
         return var_type.value
     elif inspect.isclass(python_type):

qtype/base/types.py

@@ -20,7 +20,7 @@ from typing import (
 
 from pydantic import BaseModel
 from pydantic import ConfigDict as PydanticConfigDict
-from pydantic import Field, model_validator
+from pydantic import Field, model_serializer, model_validator
 
 # JSON-serializable value types
 JSONValue = Union[
@@ -73,6 +73,11 @@ class Reference(BaseModel, Generic[ReferenceT]):
 
     ref: str = Field(..., alias="$ref")
 
+    @model_serializer(mode="plain")
+    def serialize_as_string(self) -> str:
+        """Serialize Reference as a plain string (just the ID)."""
+        return self.ref
+
 
 def _contains_reference_and_str(type_hint: Any) -> bool:
     """Check if type contains both Reference and str in a union."""

qtype/commands/convert.py

@@ -13,7 +13,7 @@ from qtype.dsl.model import Application, Document, ToolList
 logger = logging.getLogger(__name__)
 
 
-def _convert_to_yaml(doc: Application | ToolList) -> str:
+def convert_to_yaml(doc: Application | ToolList) -> str:
     """Convert a document to YAML format."""
     from pydantic_yaml import to_yaml_str
 
@@ -23,9 +23,6 @@ def _convert_to_yaml(doc: Application | ToolList) -> str:
     else:
         wrapped = doc
 
-    import pprint
-
-    pprint.pprint(wrapped)
     # NOTE: We use exclude_none but NOT exclude_unset because discriminator
     # fields like 'type' have default values and must be included in output
     return to_yaml_str(wrapped, exclude_none=True)
@@ -54,7 +51,7 @@ def convert_api(args: argparse.Namespace) -> None:
                 auths=auths,
             )
         # Convert to YAML format
-        content = _convert_to_yaml(doc)
+        content = convert_to_yaml(doc)
 
         # Write to file or stdout
         if args.output:
@@ -96,7 +93,7 @@ def convert_module(args: argparse.Namespace) -> None:
             )
 
         # Convert to YAML format
-        content = _convert_to_yaml(doc)
+        content = convert_to_yaml(doc)
 
         # Write to file or stdout
         if args.output: