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

qtype/interpreter/executors/llm_inference_executor.py

@@ -1,3 +1,4 @@
+import logging
 from typing import AsyncIterator
 
 from llama_cloud import MessageRole as LlamaMessageRole
@@ -85,6 +86,7 @@ class LLMInferenceExecutor(StepExecutor):
 
         except Exception as e:
             # Emit error event to stream so frontend can display it
+            logging.error(f"LLM Inference search failed: {e}", exc_info=True)
             await self.stream_emitter.error(str(e))
             yield message.copy_with_error(self.step.id, e)
 
@@ -109,7 +111,7 @@ class LLMInferenceExecutor(StepExecutor):
         # Convert input variables to chat messages
         inputs = []
         for input_var in self.step.inputs:
-            value = message.variables.get(input_var.id)
+            value = message.get_variable(input_var.id)
             # Convert any value type to ChatMessage, then to LlamaChatMessage
             chat_msg = variable_to_chat_message(value, input_var)
             inputs.append(to_chat_message(chat_msg))
@@ -160,9 +162,14 @@ class LLMInferenceExecutor(StepExecutor):
         if self.context.on_stream_event:
             # Generate a unique stream ID for this inference
             stream_id = f"llm-{self.step.id}-{id(message)}"
-            async with self.stream_emitter.reasoning_stream(
-                f"llm-{self.step.id}-{id(message)}-reasoning"
-            ) as reasoning:
+            reasoning_stream_id = f"llm-{self.step.id}-{id(message)}-reasoning"
+
+            async with (
+                self.stream_emitter.reasoning_stream(
+                    reasoning_stream_id
+                ) as reasoning,
+                self.stream_emitter.text_stream(stream_id) as streamer,
+            ):
                 generator = await model.astream_chat(
                     messages=inputs,
                     **(
@@ -171,26 +178,19 @@ class LLMInferenceExecutor(StepExecutor):
                         else {}
                     ),
                 )
-                async for complete_response in generator:
+                async for chat_response in generator:
+                    # Extract and emit reasoning if present
                     reasoning_text = self.__extract_stream_reasoning_(
-                        complete_response
+                        chat_response
                     )
                     if reasoning_text:
                         await reasoning.delta(reasoning_text)
 
-            async with self.stream_emitter.text_stream(stream_id) as streamer:
-                generator = await model.astream_chat(
-                    messages=inputs,
-                    **(
-                        self.step.model.inference_params
-                        if self.step.model.inference_params
-                        else {}
-                    ),
-                )
-                async for chat_response in generator:
+                    # Emit text delta
                     chat_text = chat_response.delta
-                    if chat_text.strip() != "":
-                        await streamer.delta(chat_response.delta)
+                    if chat_text is not None and chat_text.strip() != "":
+                        await streamer.delta(chat_text)
+
             # Get the final result
             chat_result = chat_response
         else:

qtype/interpreter/executors/prompt_template_executor.py

@@ -51,9 +51,7 @@ class PromptTemplateExecutor(StepExecutor):
             input_map = {}
             for var in self.step.inputs:
                 if var.id in format_args:
-                    value = message.variables.get(var.id)
-                    if value is not None:
-                        input_map[var.id] = value
+                    input_map[var.id] = message.get_variable(var.id)
 
             missing = format_args - input_map.keys()
             if missing:

qtype/interpreter/executors/sql_source_executor.py

@@ -42,8 +42,12 @@ class SQLSourceExecutor(StepExecutor):
         connect_args = {}
         if self.step.auth:
             with auth(self.step.auth, self._secret_manager) as creds:
-                if isinstance(creds, boto3.Session):
-                    connect_args["session"] = creds
+                # For AWS auth, create a boto3 session from credentials
+                from qtype.interpreter.auth.aws import AWSCredentials
+
+                if isinstance(creds, AWSCredentials):
+                    session = boto3.Session(**creds.as_kwargs())
+                    connect_args["session"] = session
         engine = create_engine(connection_string, connect_args=connect_args)
 
         output_columns = {output.id for output in self.step.outputs}

qtype/interpreter/flow.py

@@ -17,7 +17,7 @@ from qtype.interpreter.base import factory
 from qtype.interpreter.base.executor_context import ExecutorContext
 from qtype.interpreter.logging_progress import LoggingProgressCallback
 from qtype.interpreter.rich_progress import RichProgressCallback
-from qtype.interpreter.types import FlowMessage, ProgressCallback
+from qtype.interpreter.types import FlowMessage, ProgressCallback, Session
 from qtype.semantic.model import Flow
 
 logger = logging.getLogger(__name__)
@@ -106,6 +106,16 @@ async def run_flow(
             initial = [initial]
 
         if isinstance(initial, list):
+            # Handle empty list by creating a single empty message
+            if len(initial) == 0:
+                session_id = kwargs.get("session_id", "default")
+                initial = [
+                    FlowMessage(
+                        session=Session(session_id=session_id),
+                        variables={},
+                    )
+                ]
+
             span.set_attribute("flow.input_count", len(initial))
 
             # convert to async iterator

qtype/interpreter/tools/function_tool_helper.py

@@ -14,7 +14,7 @@ from pydantic import create_model
 from qtype.base.types import PrimitiveTypeEnum
 from qtype.dsl.model import ListType
 from qtype.dsl.types import PRIMITIVE_TO_PYTHON_TYPE
-from qtype.semantic.model import APITool, PythonFunctionTool, ToolParameter
+from qtype.semantic.model import APITool, PythonFunctionTool, Variable
 
 logger = logging.getLogger(__name__)
 
@@ -29,9 +29,9 @@ class FunctionToolHelper:
 
     @staticmethod
     def _qtype_type_to_python_type(
-        param: ToolParameter,
+        param: Variable,
     ) -> type:
-        """Convert QType ToolParameter type to Python type for Pydantic.
+        """Convert QType Variable type to Python type for Pydantic.
 
         The param.type has already been resolved during semantic model
         creation, so we just need to convert it to the appropriate Python
@@ -42,7 +42,7 @@ class FunctionToolHelper:
         - Unknown → str
 
         Args:
-            param: The QType ToolParameter to convert.
+            param: The QType Variable to convert.
 
         Returns:
             Python type suitable for Pydantic field annotation.
@@ -55,7 +55,8 @@ class FunctionToolHelper:
         if isinstance(param.type, ListType):
             # Create a mock parameter with the element type to recursively
             # resolve it
-            element_param = ToolParameter(
+            element_param = Variable(
+                id="temp",
                 type=param.type.element_type,
                 optional=False,
             )
@@ -74,13 +75,13 @@ class FunctionToolHelper:
     @staticmethod
     def _create_fn_schema(
         tool_name: str,
-        inputs: dict[str, ToolParameter],
+        inputs: list[Variable],
     ) -> type[BaseModel] | None:
         """Create a Pydantic model from QType tool input parameters.
 
         Args:
             tool_name: Name of the tool (used for model name).
-            inputs: Dictionary of input parameter names to ToolParameter.
+            inputs: List of input Variables.
 
         Returns:
             Pydantic BaseModel class representing the tool's input schema.
@@ -91,17 +92,17 @@ class FunctionToolHelper:
         # Each field is a tuple of (type_annotation, field_info)
         field_definitions: dict[str, Any] = {}
 
-        for param_name, param in inputs.items():
+        for param in inputs:
             python_type = FunctionToolHelper._qtype_type_to_python_type(param)
 
             # Create field with optional annotation
             if param.optional:
-                field_definitions[param_name] = (
+                field_definitions[param.id] = (
                     python_type | None,  # type: ignore[valid-type]
                     PydanticField(default=None),
                 )
             else:
-                field_definitions[param_name] = (
+                field_definitions[param.id] = (
                     python_type,
                     PydanticField(...),
                 )

qtype/interpreter/types.py

@@ -1,11 +1,38 @@
 from typing import Any, Dict, Literal, Optional, Protocol, Union
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, model_serializer
 
 from qtype.base.types import StrictBaseModel
 from qtype.dsl.domain_types import ChatMessage
 from qtype.semantic.model import Step
 
+
+class _UnsetType:
+    """Sentinel representing an unset variable.
+
+    Distinguishes between:
+    - Variable never mentioned (not in dict)
+    - Variable explicitly unset (UNSET value in dict)
+    - Variable set to None (None value in dict)
+    """
+
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __repr__(self) -> str:
+        return "UNSET"
+
+    def __bool__(self) -> bool:
+        return False
+
+
+UNSET = _UnsetType()
+
+
 # Stream Event Types (Discriminated Union)
 # These events are emitted by executors during flow execution
 # and can be converted to Vercel UI chunks for frontend display
@@ -293,8 +320,9 @@ class FlowMessage(BaseModel):
     """
 
     model_config = ConfigDict(
-        frozen=True
-    )  # Enforces immutability at the model level
+        frozen=True,
+        arbitrary_types_allowed=True,  # Allow UNSET sentinel
+    )
 
     session: Session
     variables: Dict[str, Any] = Field(
@@ -307,6 +335,49 @@ class FlowMessage(BaseModel):
         """Checks if this state has encountered an error."""
         return self.error is not None
 
+    def is_set(self, var_id: str) -> bool:
+        """Check if a variable is set (not UNSET, may be None)."""
+        value = self.variables.get(var_id, UNSET)
+        return value is not UNSET
+
+    def get_variable(self, var_id: str, *, default: Any = UNSET) -> Any:
+        """Get variable value, raising if unset and no default provided.
+
+        Args:
+            var_id: Variable identifier
+            default: Value to return if variable is unset. If not provided,
+                    raises ValueError on unset variables.
+
+        Returns:
+            Variable value (may be None if explicitly set to None)
+
+        Raises:
+            ValueError: If variable is unset and no default provided
+
+        Examples:
+            # Required variable - throws if unset
+            value = message.get_variable("user_input")
+
+            # Optional variable - returns None if unset
+            value = message.get_variable("optional_field", default=None)
+
+            # Optional with custom default
+            value = message.get_variable("count", default=0)
+        """
+        value = self.variables.get(var_id, UNSET)
+
+        if value is UNSET:
+            if default is UNSET:
+                raise ValueError(
+                    (
+                        f"Required variable '{var_id}' is not set. "
+                        f"Available variables: {list(self.variables.keys())}"
+                    )
+                )
+            return default
+
+        return value
+
     def copy_with_error(self, step_id: str, exc: Exception) -> "FlowMessage":
         """Returns a copy of this state marked as failed."""
         return self.model_copy(
@@ -319,15 +390,29 @@ class FlowMessage(BaseModel):
             }
         )
 
-    # It's useful to have copy-on-write style helpers
     def copy_with_variables(
         self, new_variables: dict[str, Any]
     ) -> "FlowMessage":
+        """Create a new FlowMessage with updated variables.
+
+        Note: Can set variables to UNSET to explicitly mark them as unset.
+        """
         new_vars = self.variables.copy()
         new_vars.update(new_variables)
         new_state = self.model_copy(update={"variables": new_vars})
         return new_state
 
+    @model_serializer
+    def serialize_model(self):
+        """Custom serialization that excludes UNSET variables."""
+        return {
+            "session": self.session,
+            "variables": {
+                k: v for k, v in self.variables.items() if v is not UNSET
+            },
+            "error": self.error,
+        }
+
 
 class InterpreterError(Exception):
     """Base exception class for ProtoGen interpreter errors."""

qtype/interpreter/typing.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import uuid
-from typing import Any, Type, get_origin
+from typing import Any, Type
 
-from pydantic import BaseModel, Field, TypeAdapter, create_model
+from pydantic import BaseModel, Field, create_model
 
 from qtype.dsl.model import ListType, PrimitiveTypeEnum
 from qtype.dsl.model import Variable as DSLVariable
@@ -138,37 +138,36 @@ def flow_results_to_output_container(
     return output_container(outputs=outputs, errors=errors)
 
 
-def instantiate_variable(variable: DSLVariable, value: Any) -> Any:
+def convert_dict_to_typed_variables(
+    data: dict[str, Any], variables: list[Variable]
+) -> dict[str, Any]:
     """
-    Unified contract to ensure data matches its QType definition.
-    Handles CustomTypes, DomainTypes, and Primitives.
+    Convert a dictionary of raw values to properly typed variables.
+
+    Uses Pydantic model validation to convert all values at once based on
+    Variable type declarations. This is more efficient than converting each
+    field individually.
+
+    Args:
+        data: Dictionary with raw values (e.g., from DataFrame row)
+        variables: List of Variable definitions with type information
+
+    Returns:
+        Dictionary with values converted to their declared types
+
+    Raises:
+        ValidationError: If values cannot be converted to declared types
     """
-    target_type, _ = _get_variable_type(variable)
+    # Create a Pydantic model from the variable definitions
+    model_class = create_model(
+        "TypedVariables",
+        __base__=BaseModel,
+        **_fields_from_variables(variables),
+    )
 
-    # 1. Handle the 'Parameterized Generic' Check (The isinstance fix)
-    # We check if target_type is a generic (like list[T]) vs a simple class.
-    origin = get_origin(target_type)
+    # Validate and convert the data using Pydantic
+    validated = model_class.model_validate(data)
 
-    if origin is None:
-        # It's a simple type (int, RAGChunk, etc.)
-        if isinstance(value, target_type):
-            return value
-    else:
-        # It's a generic (list[str], etc.).
-        # We skip the identity check and let TypeAdapter handle it.
-        pass
-
-    # 2. Handle Pydantic Models (Custom/Domain Types)
-    if hasattr(target_type, "model_validate"):
-        return target_type.model_validate(value)  # type: ignore[misc]
-
-    # 3. Handle Primitives & Complex Python Types (List, Optional, Union)
-    try:
-        # TypeAdapter is the "V2 way" to validate things that aren't
-        # full Pydantic models (like List[int] or Optional[str])
-        return TypeAdapter(target_type).validate_python(value)
-    except Exception:
-        # Fallback to your original manual cast if TypeAdapter is overkill
-        if isinstance(target_type, type):
-            return target_type(value)
-        raise ValueError(f"Unsupported target type: {target_type}")
+    # Return as dict but preserve actual typed instances (not serialized)
+    # Use __dict__ to get the actual field values without serialization
+    return dict(validated)