qtype 0.1.12__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,
 )
 
@@ -202,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.
@@ -216,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
     )
@@ -240,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("?")
@@ -248,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
@@ -258,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(
@@ -297,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(
@@ -306,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),
@@ -339,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,

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/commands/generate.py

@@ -2,24 +2,48 @@ import argparse
 import json
 import logging
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 from qtype.dsl.model import Document
 
 logger = logging.getLogger(__name__)
 
 
+def generate_aws_bedrock_models() -> list[dict[str, Any]]:
+    """Generate AWS Bedrock model definitions.
+
+    Returns:
+        List of model definitions for AWS Bedrock models.
+
+    Raises:
+        ImportError: If boto3 is not installed.
+        Exception: If AWS API call fails.
+    """
+    import boto3  # type: ignore[import-untyped]
+
+    logger.info("Discovering AWS Bedrock models...")
+    client = boto3.client("bedrock")
+    models = client.list_foundation_models()
+
+    model_definitions = []
+    for model_summary in models.get("modelSummaries", []):
+        model_definitions.append(
+            {
+                "id": model_summary["modelId"],
+                "provider": "aws-bedrock",
+            }
+        )
+
+    logger.info(f"Discovered {len(model_definitions)} AWS Bedrock models")
+    return model_definitions
+
+
 def run_dump_commons_library(args: argparse.Namespace) -> None:
     """Generate commons library tools and AWS Bedrock models."""
-    import logging
     from pathlib import Path
 
-    from qtype.application.facade import QTypeFacade
     from qtype.dsl.model import Model, ModelList
 
-    logger = logging.getLogger(__name__)
-    facade = QTypeFacade()
-
     try:
         # Generate common tools using convert module functionality
         logger.info("Generating common tools...")
@@ -38,7 +62,7 @@ def run_dump_commons_library(args: argparse.Namespace) -> None:
         # Generate AWS Bedrock models
         logger.info("Generating AWS Bedrock models...")
         try:
-            model_definitions = facade.generate_aws_bedrock_models()
+            model_definitions = generate_aws_bedrock_models()
 
             model_list = ModelList(
                 root=[
@@ -80,6 +104,51 @@ def run_generate_documentation(args: argparse.Namespace) -> None:
     generate_documentation(Path(args.output))
 
 
+def _copy_resource_file(resource, rel_path: Path, output_file: Path) -> None:
+    """Copy a file from a resource directory to an output location."""
+    content = resource.get_file(str(rel_path))
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    output_file.write_text(content, encoding="utf-8")
+
+
+def run_generate_skill(args: argparse.Namespace) -> None:
+    """Generate a Claude skill with QType documentation and examples.
+
+    Args:
+        args: Command-line arguments with 'output' path.
+    """
+    from qtype.mcp.server import _docs_resource, _examples_resource
+
+    output_path = Path(args.output) / "qtype-architect"
+
+    # Copy skill documentation files
+    skills_path = _docs_resource.get_path() / "skills" / "architect"
+    skill_count = 0
+    for skill_file in skills_path.rglob("*.*"):
+        rel_path = skill_file.relative_to(_docs_resource.get_path())
+        _copy_resource_file(
+            _docs_resource,
+            rel_path,
+            output_path / rel_path.relative_to("skills/architect"),
+        )
+        skill_count += 1
+
+    # Copy all example files
+    example_count = 0
+    for yaml_file in _examples_resource.get_path().rglob("*.yaml"):
+        rel_path = yaml_file.relative_to(_examples_resource.get_path())
+        if "legacy" not in rel_path.parts:
+            _copy_resource_file(
+                _examples_resource, rel_path, output_path / "assets" / rel_path
+            )
+            example_count += 1
+
+    logger.info(
+        f"Skill generated at {output_path}: "
+        f"{skill_count} docs, {example_count} examples"
+    )
+
+
 def generate_schema(args: argparse.Namespace) -> None:
     """Generate and output the JSON schema for Document.
 
@@ -184,6 +253,20 @@ def parser(subparsers: argparse._SubParsersAction) -> None:
     )
     dsl_parser.set_defaults(func=run_generate_documentation)
 
+    # Parser for generating Agent skills
+    skill_parser = generate_subparsers.add_parser(
+        "skills",
+        help="Generates Agent skills with QType documentation and examples.",
+    )
+    skill_parser.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        default=".claude/skills",
+        help="Output directory for the skills (default: .claude/skills)",
+    )
+    skill_parser.set_defaults(func=run_generate_skill)
+
     # Parser for generating the semantic model
     # only add this if networkx and ruff are installed
     try: