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

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:

qtype/commands/generate.py

@@ -51,7 +51,11 @@ def run_dump_commons_library(args: argparse.Namespace) -> None:
             )
 
             # Convert to YAML and save
-            content = facade.convert_document(model_list)
+            from pydantic_yaml import to_yaml_str
+
+            content = to_yaml_str(
+                model_list, exclude_none=True, exclude_unset=True
+            )
             output_path = Path(f"{args.prefix}/aws.bedrock.models.qtype.yaml")
             output_path.write_text(content, encoding="utf-8")
             logger.info(f"AWS Bedrock models exported to {output_path}")
@@ -118,8 +122,8 @@ def generate_schema(args: argparse.Namespace) -> None:
 
     schema["$defs"]["qtype_env_var"] = {
         "type": "string",
-        "pattern": "^.*\\$\\{[^}:]+(?::[^}]*)?\\}.*$",
-        "description": "String with environment variable substitution using ${VAR_NAME} or ${VAR_NAME:default} syntax",
+        "pattern": "^.*\\$\\{[^}:]+(?::-[^}]*)?\\}.*$",
+        "description": "String with environment variable substitution using ${VAR_NAME} or ${VAR_NAME:-default} syntax",
     }
 
     output = json.dumps(schema, indent=2)

qtype/commands/mcp.py

@@ -0,0 +1,68 @@
+"""
+Command-line interface for starting the QType MCP server.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from typing import Any
+
+from qtype.mcp.server import mcp
+
+logger = logging.getLogger(__name__)
+
+
+def main(args: Any) -> None:
+    """
+    Start the QType MCP server with the specified transport.
+
+    Args:
+        args: Arguments passed from the command line or calling context.
+    """
+
+    # Update server settings with CLI arguments
+    mcp.settings.host = args.host
+    mcp.settings.port = args.port
+
+    logger.info(f"Starting QType MCP server with {args.transport} transport")
+
+    if args.transport in ("sse", "streamable-http"):
+        logger.info(f"Server will be available at {args.host}:{args.port}")
+
+    # Run the server with the specified transport
+    mcp.run(transport=args.transport)
+
+
+def parser(subparsers: argparse._SubParsersAction) -> None:
+    """Set up the mcp subcommand parser.
+
+    Args:
+        subparsers: The subparsers object to add the command to.
+    """
+    cmd_parser = subparsers.add_parser(
+        "mcp",
+        help="Start the QType MCP server for AI agent integration.",
+    )
+    cmd_parser.add_argument(
+        "-t",
+        "--transport",
+        type=str,
+        choices=["stdio", "sse", "streamable-http"],
+        default="stdio",
+        help="Transport protocol to use (default: stdio)",
+    )
+    cmd_parser.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="Host to bind to for HTTP/SSE transports (default: 0.0.0.0)",
+    )
+    cmd_parser.add_argument(
+        "-p",
+        "--port",
+        type=int,
+        default=8000,
+        help="Port to bind to for HTTP/SSE transports (default: 8000)",
+    )
+    cmd_parser.set_defaults(func=main)

qtype/commands/validate.py

@@ -10,7 +10,7 @@ import sys
 from pathlib import Path
 from typing import Any
 
-from qtype.base.exceptions import LoadError, SemanticError, ValidationError
+from qtype.base.exceptions import LoadError, ValidationError
 from qtype.dsl.linker import DuplicateComponentError, ReferenceNotFoundError
 from qtype.dsl.loader import YAMLLoadError
 from qtype.dsl.model import Application as DSLApplication
@@ -60,9 +60,9 @@ def main(args: Any) -> None:
     except ValidationError as e:
         logger.error(f"❌ Validation failed: {e}")
         sys.exit(1)
-    except SemanticError as e:
-        logger.error(f"❌ Semantic validation failed: {e}")
-        sys.exit(1)
+    # except SemanticError as e:
+    #     logger.error(f"❌ Semantic validation failed: {e}")
+    #     sys.exit(1)
 
     # If printing is requested, load and print the document
     if args.print:

qtype/dsl/custom_types.py

@@ -43,7 +43,8 @@ def build_dynamic_types(
             resolved_type = ForwardRef(type_str)
 
         if is_optional:
-            return Union[resolved_type, None], True
+            # Type checker: resolved_type is runtime-constructed type
+            return Union[resolved_type, None], True  # type: ignore[valid-type]
 
         return resolved_type, False
 

qtype/dsl/linker.py

@@ -253,18 +253,26 @@ def _resolve_rootmodel_references(
         model: RootModel instance to resolve
         lookup_map: Map of component IDs to objects
     """
-    root_list = model.root  # type: ignore
-    if not isinstance(root_list, list):
-        return
+    root_value = model.root  # type: ignore[attr-defined]
 
-    for i, item in enumerate(root_list):
+    def _resolve_root_item(item: Any) -> Any:
         match item:
             case base_types.Reference():
-                root_list[i] = _resolve_reference(
-                    item.ref, type(item), lookup_map
-                )
+                return _resolve_reference(item.ref, type(item), lookup_map)
             case BaseModel():
                 _resolve_all_references(item, lookup_map)
+                return item
+            case _:
+                return item
+
+    # RootModel can wrap either a list (e.g., ToolList) or a single model
+    # (e.g., Document -> Application). We need to traverse both.
+    if isinstance(root_value, list):
+        for i, item in enumerate(root_value):
+            root_value[i] = _resolve_root_item(item)
+        return
+    else:
+        model.root = _resolve_root_item(root_value)  # type: ignore[attr-defined]
 
 
 def _resolve_list_references(

qtype/dsl/loader.py

@@ -6,7 +6,7 @@ This module provides two explicit functions for loading YAML:
 - load_yaml_string(content, base_path): Load YAML from a string
 
 Both support:
-- Environment variable substitution (${VAR} or ${VAR:default})
+- Environment variable substitution (${VAR} or ${VAR:-default})
 - File inclusion (!include and !include_raw)
 - Multiple URI schemes via fsspec (local, http, s3, etc.)
 
@@ -81,7 +81,7 @@ def _substitute_env_vars(value: str) -> str:
     """
     Substitute environment variables in a string.
 
-    Supports ${VAR_NAME} or ${VAR_NAME:default} syntax.
+    Supports ${VAR_NAME} or ${VAR_NAME:-default} syntax.
 
     Args:
         value: String containing environment variable references
@@ -92,7 +92,7 @@ def _substitute_env_vars(value: str) -> str:
     Raises:
         ValueError: If required environment variable is not found
     """
-    pattern = r"\$\{([^}:]+)(?::([^}]*))?\}"
+    pattern = r"\$\{([^}:]+)(?::-([^}]*))?\}"
 
     def replace_env_var(match: re.Match[str]) -> str:
         var_name = match.group(1)

qtype/dsl/model.py

@@ -285,9 +285,10 @@ class ToolParameter(BaseModel):
     @model_serializer
     def _model_serializer(self):
         # Use the default serialization, but ensure 'type' is a string
-        data = self.model_dump()
-        data["type"] = self._serialize_type(data.get("type"))
-        return data
+        return {
+            "type": self._serialize_type(self.type),
+            "optional": self.optional,
+        }
 
 
 class ListType(BaseModel):
@@ -656,6 +657,26 @@ class InvokeTool(Step, ConcurrentStepMixin):
         description="Mapping from variable references to tool output parameter names.",
     )
 
+    @model_validator(mode="after")
+    def infer_inputs_outputs_from_bindings(self) -> "InvokeTool":
+        def _merge_vars(
+            existing: list[Reference[Variable] | str],
+            bindings: dict[str, str],
+        ) -> list[Reference[Variable] | str]:
+            """Merge existing variables with bindings and deduplicate."""
+            # NOTE: doesn't handle references. You may duplicate inputs here..
+            existing_ids = [item for item in existing if isinstance(item, str)]
+            inferred_ids = list(bindings.values())
+            merged_ids: list[Reference[Variable] | str] = [
+                Reference[Variable].model_validate({"$ref": var_id})
+                for var_id in dict.fromkeys(existing_ids + inferred_ids)
+            ]
+            return merged_ids
+
+        self.inputs = _merge_vars(self.inputs, self.input_bindings)
+        self.outputs = _merge_vars(self.outputs, self.output_bindings)
+        return self
+
 
 class InvokeFlow(Step):
     """Invokes a flow with input and output bindings."""

qtype/interpreter/api.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 from contextlib import asynccontextmanager
 from pathlib import Path
+from typing import Any
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -86,8 +87,10 @@ class APIExecutor:
         if ui_enabled:
             # Add CORS middleware only for localhost development
             if self.host in ("localhost", "127.0.0.1", "0.0.0.0"):
+                from typing import cast
+
                 app.add_middleware(
-                    CORSMiddleware,
+                    cast(Any, CORSMiddleware),
                     allow_origins=["*"],
                     allow_credentials=True,
                     allow_methods=["*"],

qtype/interpreter/base/base_step_executor.py

@@ -355,7 +355,9 @@ class StepExecutor(ABC):
                 ):
                     serialized = [to_cache_value(m, self.step) for m in buf]
                     self.cache.set(
-                        key, serialized, expire=self.step.cache_config.ttl
+                        key,
+                        serialized,
+                        expire=self.step.cache_config.ttl,  # type: ignore[union-attr]
                     )  # type: ignore
 
     async def _process_message_with_telemetry(

qtype/interpreter/conversions.py

@@ -331,7 +331,7 @@ def to_embedding_model(
             OpenAIEmbedding,
         )
 
-        api_key = None
+        api_key: str | None = None
         if model.auth:
             with auth(model.auth, secret_manager) as provider:
                 if not isinstance(provider, APIKeyAuthProvider):
@@ -343,7 +343,7 @@ def to_embedding_model(
                 api_key = provider.api_key  # type: ignore[assignment]
 
         openai_embedding: BaseEmbedding = OpenAIEmbedding(
-            api_key=api_key,
+            api_key=api_key,  # type: ignore[arg-type]
             model_name=model.model_id if model.model_id else model.id,
         )
         return openai_embedding
@@ -523,7 +523,11 @@ def from_chat_message(message: LlamaChatMessage) -> ChatMessage:
                 f"Unsupported content block type: {type(block)}"
             )
 
-    return ChatMessage(role=message.role, blocks=blocks)
+    # Convert llama_index MessageRole to our MessageRole
+    from qtype.dsl.domain_types import MessageRole as QTypeMessageRole
+
+    role = QTypeMessageRole(message.role.value)
+    return ChatMessage(role=role, blocks=blocks)
 
 
 def to_text_splitter(splitter: DocumentSplitter) -> Any:

qtype/interpreter/executors/construct_executor.py

@@ -53,7 +53,7 @@ class ConstructExecutor(StepExecutor):
                 }
                 # use the mapping to convert variable names to
                 inputs = {
-                    self.step.field_mapping.get(var_name, var_name): value
+                    self.step.field_mapping.get(var_name, var_name): value  # type: ignore[attr-defined]
                     for var_name, value in input_values.items()
                 }
             else:

qtype/interpreter/executors/file_source_executor.py

@@ -40,10 +40,10 @@ class FileSourceExecutor(StepExecutor):
         output_columns = {output.id for output in self.step.outputs}
 
         # get the path
-        if isinstance(self.step.path, ConstantPath):
-            file_path = self.step.path
+        if isinstance(self.step.path, ConstantPath):  # type: ignore[attr-defined]
+            file_path = self.step.path  # type: ignore[attr-defined]
         else:
-            file_path = message.variables.get(self.step.path.id)
+            file_path = message.variables.get(self.step.path.id)  # type: ignore[attr-defined]
             if not file_path:
                 raise ValueError(
                     (

qtype/interpreter/executors/file_writer_executor.py

@@ -48,8 +48,8 @@ class FileWriterExecutor(BatchedStepExecutor):
         if len(self.step.outputs):
             output_name = self.step.outputs[0].id
 
-        if isinstance(self.step.path, ConstantPath):
-            file_path = self.step.path.uri
+        if isinstance(self.step.path, ConstantPath):  # type: ignore[attr-defined]
+            file_path = self.step.path.uri  # type: ignore[attr-defined]
             df = self.to_pandas(batch)
             # A fixed path is provided -- just write all of the data
             await self.stream_emitter.status(
@@ -67,12 +67,12 @@ class FileWriterExecutor(BatchedStepExecutor):
 
         else:
             # Group messages by file path (path is a Variable in this branch)
-            if not isinstance(self.step.path, Variable):
+            if not isinstance(self.step.path, Variable):  # type: ignore[attr-defined]
                 raise ValueError(
                     "Expected path to be a Variable in dynamic path case."
                 )
 
-            path_var_id = self.step.path.id
+            path_var_id = self.step.path.id  # type: ignore[attr-defined]
 
             # Sort messages by file path for groupby
             sorted_batch = sorted(

qtype/interpreter/executors/index_upsert_executor.py

@@ -145,7 +145,7 @@ class IndexUpsertExecutor(BatchedStepExecutor):
             nodes.append(node)
 
         # Batch upsert all nodes to the vector store
-        await self._vector_store.async_add(nodes)
+        await self._vector_store.async_add(nodes)  # type: ignore[union-attr]
         num_inserted = len(items)
 
         # Emit status update

qtype/interpreter/executors/sql_source_executor.py

@@ -41,7 +41,7 @@ class SQLSourceExecutor(StepExecutor):
         connection_string = self._resolve_secret(self.step.connection)
         connect_args = {}
         if self.step.auth:
-            with auth(self.step.auth) as creds:
+            with auth(self.step.auth, self._secret_manager) as creds:
                 if isinstance(creds, boto3.Session):
                     connect_args["session"] = creds
         engine = create_engine(connection_string, connect_args=connect_args)

qtype/interpreter/resource_cache.py

@@ -25,9 +25,11 @@ def cached_resource(func: Callable[..., Any]) -> Callable[..., Any]:
 
     @functools.wraps(func)
     def wrapper(*args: Any, **kwargs: Any) -> Any:
+        # Use getattr with fallback for callables that aren't functions
+        qualname = getattr(func, "__qualname__", repr(func))
         cache_key = (
             func.__module__,
-            func.__qualname__,
+            qualname,
             args,
             tuple(sorted(kwargs.items())),
         )

qtype/interpreter/rich_progress.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import threading
 from collections import deque
-from typing import Deque, Dict
+from typing import Any, Deque, Dict
 
 from rich.console import Console
 from rich.live import Live
@@ -11,6 +11,7 @@ from rich.panel import Panel
 from rich.progress import (
     Progress,
     ProgressColumn,
+    TaskID,
     TaskProgressColumn,
     TextColumn,
     TimeElapsedColumn,
@@ -140,7 +141,7 @@ class RichProgressCallback(ProgressCallback):
         )
 
         # Map step_id -> Rich task id
-        self.tasks: Dict[str, int] = {}
+        self.tasks: dict[str, TaskID] = {}
         self._started = False
 
         # Pre-create tasks in the desired order if provided
@@ -202,7 +203,9 @@ class RichProgressCallback(ProgressCallback):
             if total_items is not None:
                 update_kwargs["total"] = total_items
 
-            self.progress.update(task_id, **update_kwargs)
+            from typing import cast
+
+            self.progress.update(task_id, **cast(Any, update_kwargs))
 
     def compute_color(self, items_processed: int, items_in_error: int) -> str:
         # Avoid divide-by-zero

qtype/interpreter/stream/chat/converter.py

@@ -258,10 +258,12 @@ class StreamEventConverter:
         3. ToolInputAvailableChunk - Complete input ready, tool can execute
         """
         # 1. Start tool input streaming
-        yield ToolInputStartChunk(
-            toolCallId=event.tool_call_id,
-            toolName=event.tool_name,
-            providerExecuted=True,  # Tools are executed on the server
+        yield ToolInputStartChunk.model_validate(
+            {
+                "toolCallId": event.tool_call_id,
+                "toolName": event.tool_name,
+                "providerExecuted": True,
+            }
         )
 
         # 2. Stream the input as JSON text delta
@@ -274,11 +276,13 @@ class StreamEventConverter:
         )
 
         # 3. Signal input is complete and ready for execution
-        yield ToolInputAvailableChunk(
-            toolCallId=event.tool_call_id,
-            toolName=event.tool_name,
-            input=event.tool_input,
-            providerExecuted=True,  # Tools are executed on the server
+        yield ToolInputAvailableChunk.model_validate(
+            {
+                "toolCallId": event.tool_call_id,
+                "toolName": event.tool_name,
+                "input": event.tool_input,
+                "providerExecuted": True,
+            }
         )
 
     def _convert_tool_execution_end(
@@ -289,10 +293,12 @@ class StreamEventConverter:
 
         Signals successful tool completion with output.
         """
-        yield ToolOutputAvailableChunk(
-            toolCallId=event.tool_call_id,
-            output=event.tool_output,
-            providerExecuted=True,  # Tools are executed on the server
+        yield ToolOutputAvailableChunk.model_validate(
+            {
+                "toolCallId": event.tool_call_id,
+                "output": event.tool_output,
+                "providerExecuted": True,
+            }
         )
 
     def _convert_tool_execution_error(
@@ -303,10 +309,12 @@ class StreamEventConverter:
 
         Signals tool execution failure with error message.
         """
-        yield ToolOutputErrorChunk(
-            toolCallId=event.tool_call_id,
-            errorText=event.error_message,
-            providerExecuted=True,  # Tools are executed on the server
+        yield ToolOutputErrorChunk.model_validate(
+            {
+                "toolCallId": event.tool_call_id,
+                "errorText": event.error_message,
+                "providerExecuted": True,
+            }
         )
 
     def _convert_error(self, event: ErrorEvent) -> Iterator[UIMessageChunk]:

qtype/interpreter/stream/chat/ui_request_to_domain_type.py

@@ -39,11 +39,11 @@ def _ui_message_to_domain_type(message: UIMessage) -> ChatMessage:
     for part in message.parts:
         if part.type == "text":
             blocks.append(
-                ChatContent(type=PrimitiveTypeEnum.text, content=part.text)
+                ChatContent(type=PrimitiveTypeEnum.text, content=part.text)  # type: ignore[attr-defined]
             )
         elif part.type == "reasoning":
             blocks.append(
-                ChatContent(type=PrimitiveTypeEnum.text, content=part.text)
+                ChatContent(type=PrimitiveTypeEnum.text, content=part.text)  # type: ignore[attr-defined]
             )
         elif part.type == "file":
             blocks.append(

qtype/interpreter/typing.py

@@ -25,11 +25,9 @@ def _get_variable_type(var: DSLVariable) -> tuple[Type, dict[str, Any]]:
         python_type = PRIMITIVE_TO_PYTHON_TYPE.get(var.type, str)
         field_metadata["qtype_type"] = var.type.value
     elif isinstance(var.type, ListType):
-        python_type = list[
-            _get_variable_type(DSLVariable(id="", type=var.type.element_type))[
-                0
-            ]
-        ]
+        element_var = DSLVariable(id="", type=var.type.element_type)
+        element_type, _ = _get_variable_type(element_var)
+        python_type = list[element_type]  # type: ignore[valid-type]
         field_metadata["qtype_type"] = f"list[{var.type.element_type}]"
     elif (
         isinstance(var.type, type)
@@ -82,7 +80,7 @@ def create_output_container_type(flow: Flow) -> Type[BaseModel]:
         Field(description="List of errored execution outputs"),
     )
     fields["outputs"] = (
-        list[output_shape],
+        list[output_shape],  # type: ignore[valid-type]
         Field(description="List of successful execution outputs"),
     )
     return create_model(f"{flow.id}Response", __base__=BaseModel, **fields)  # type: ignore
@@ -162,7 +160,7 @@ def instantiate_variable(variable: DSLVariable, value: Any) -> Any:
 
     # 2. Handle Pydantic Models (Custom/Domain Types)
     if hasattr(target_type, "model_validate"):
-        return target_type.model_validate(value)
+        return target_type.model_validate(value)  # type: ignore[misc]
 
     # 3. Handle Primitives & Complex Python Types (List, Optional, Union)
     try: