qtype 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

qtype/interpreter/ui/index.txt

@@ -12,7 +12,7 @@ f:"$Sreact.suspense"
 :HL["./_next/static/media/569ce4b8f30dc480-s.p.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
 :HL["./_next/static/media/93f479601ee12b01-s.p.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
 :HL["./_next/static/css/a262c53826df929b.css","style"]
-0:{"P":null,"b":"uMm4B0RSTGhXxgH3rTfwc","p":".","c":["",""],"i":false,"f":[[["",{"children":["__PAGE__",{}]},"$undefined","$undefined",true],["",["$","$1","c",{"children":[[["$","link","0",{"rel":"stylesheet","href":"./_next/static/css/a262c53826df929b.css","precedence":"next","crossOrigin":"$undefined","nonce":"$undefined"}]],["$","html",null,{"lang":"en","children":["$","body",null,{"className":"__variable_6de60c __variable_152ec0 antialiased","children":["$","$L2",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L3",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":[[["$","title",null,{"children":"404: This page could not be found."}],["$","div",null,{"style":{"fontFamily":"system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"","height":"100vh","textAlign":"center","display":"flex","flexDirection":"column","alignItems":"center","justifyContent":"center"},"children":["$","div",null,{"children":[["$","style",null,{"dangerouslySetInnerHTML":{"__html":"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"}}],["$","h1",null,{"className":"next-error-h1","style":{"display":"inline-block","margin":"0 20px 0 0","padding":"0 23px 0 0","fontSize":24,"fontWeight":500,"verticalAlign":"top","lineHeight":"49px"},"children":404}],["$","div",null,{"style":{"display":"inline-block"},"children":["$","h2",null,{"style":{"fontSize":14,"fontWeight":400,"lineHeight":"49px","margin":0},"children":"This page could not be found."}]}]]}]}]],[]],"forbidden":"$undefined","unauthorized":"$undefined"}]}]}]]}],{"children":["__PAGE__",["$","$1","c",{"children":[["$","$L4",null,{"Component":"$5","searchParams":{},"params":{},"promises":["$@6","$@7"]}],null,["$","$L8",null,{"children":["$L9",["$","$La",null,{"promise":"$@b"}]]}]]}],{},null,false]},null,false],["$","$1","h",{"children":[null,[["$","$Lc",null,{"children":"$Ld"}],["$","meta",null,{"name":"next-size-adjust","content":""}]],["$","$Le",null,{"children":["$","div",null,{"hidden":true,"children":["$","$f",null,{"fallback":null,"children":"$L10"}]}]}]]}],false]],"m":"$undefined","G":["$11",[]],"s":false,"S":true}
+0:{"P":null,"b":"OT8QJQW3J70VbDWWfrEMT","p":".","c":["",""],"i":false,"f":[[["",{"children":["__PAGE__",{}]},"$undefined","$undefined",true],["",["$","$1","c",{"children":[[["$","link","0",{"rel":"stylesheet","href":"./_next/static/css/a262c53826df929b.css","precedence":"next","crossOrigin":"$undefined","nonce":"$undefined"}]],["$","html",null,{"lang":"en","children":["$","body",null,{"className":"__variable_6de60c __variable_152ec0 antialiased","children":["$","$L2",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L3",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":[[["$","title",null,{"children":"404: This page could not be found."}],["$","div",null,{"style":{"fontFamily":"system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"","height":"100vh","textAlign":"center","display":"flex","flexDirection":"column","alignItems":"center","justifyContent":"center"},"children":["$","div",null,{"children":[["$","style",null,{"dangerouslySetInnerHTML":{"__html":"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"}}],["$","h1",null,{"className":"next-error-h1","style":{"display":"inline-block","margin":"0 20px 0 0","padding":"0 23px 0 0","fontSize":24,"fontWeight":500,"verticalAlign":"top","lineHeight":"49px"},"children":404}],["$","div",null,{"style":{"display":"inline-block"},"children":["$","h2",null,{"style":{"fontSize":14,"fontWeight":400,"lineHeight":"49px","margin":0},"children":"This page could not be found."}]}]]}]}]],[]],"forbidden":"$undefined","unauthorized":"$undefined"}]}]}]]}],{"children":["__PAGE__",["$","$1","c",{"children":[["$","$L4",null,{"Component":"$5","searchParams":{},"params":{},"promises":["$@6","$@7"]}],null,["$","$L8",null,{"children":["$L9",["$","$La",null,{"promise":"$@b"}]]}]]}],{},null,false]},null,false],["$","$1","h",{"children":[null,[["$","$Lc",null,{"children":"$Ld"}],["$","meta",null,{"name":"next-size-adjust","content":""}]],["$","$Le",null,{"children":["$","div",null,{"hidden":true,"children":["$","$f",null,{"fallback":null,"children":"$L10"}]}]}]]}],false]],"m":"$undefined","G":["$11",[]],"s":false,"S":true}
 6:{}
 7:"$0:f:0:1:2:children:1:props:children:0:props:params"
 d:[["$","meta","0",{"charSet":"utf-8"}],["$","meta","1",{"name":"viewport","content":"width=device-width, initial-scale=1"}]]

qtype/loader.py

@@ -7,15 +7,15 @@ from __future__ import annotations
 import os
 import re
 from pathlib import Path
-from typing import Any, Type
+from typing import Any
 from urllib.parse import urljoin, urlparse
 
-import fsspec
+import fsspec  # type: ignore[import-untyped]
 import yaml
 from dotenv import load_dotenv
-from fsspec.core import url_to_fs
-from pydantic import BaseModel
+from fsspec.core import url_to_fs  # type: ignore[import-untyped]
 
+from qtype.base.types import CustomTypeRegistry, DocumentRootType
 from qtype.dsl import model as dsl
 from qtype.dsl.custom_types import build_dynamic_types
 from qtype.dsl.validator import validate
@@ -182,7 +182,7 @@ def _include_raw_constructor(loader: YamlLoader, node: yaml.ScalarNode) -> str:
 
     try:
         with fsspec.open(resolved_path, "r", encoding="utf-8") as f:
-            return f.read()  # type: ignore[misc]
+            return f.read()  # type: ignore[no-any-return]
     except Exception as e:
         msg = f"Failed to load included file '{resolved_path}': {e}"
         raise FileNotFoundError(msg) from e
@@ -253,7 +253,7 @@ def load_yaml_from_string(
     # Use the string stream directly with the loader
     result = yaml.load(stream, Loader=YamlLoader)
 
-    return result
+    return result  # type: ignore[no-any-return]
 
 
 def load_yaml(content: str) -> dict[str, Any]:
@@ -310,10 +310,7 @@ def load_yaml(content: str) -> dict[str, Any]:
         return load_yaml_from_string(content)
 
 
-ResolveableType = dsl.Agent | dsl.Application | dsl.Flow | list
-
-
-def _resolve_root(doc: dsl.Document) -> ResolveableType:
+def _resolve_root(doc: dsl.Document) -> DocumentRootType:
     root = doc.root
     # If the docroot is a type that ends in the name `List`, resolve it again
     types_to_resolve = set(
@@ -330,11 +327,8 @@ def _resolve_root(doc: dsl.Document) -> ResolveableType:
     return root  # type: ignore[return-value]
 
 
-CustomTypeRegistry = dict[str, Type[BaseModel]]
-
-
 def _list_dynamic_types_from_document(
-    loaded_yaml: dict[str, Any]
+    loaded_yaml: dict[str, Any],
 ) -> list[dict]:
     """
     Build dynamic types from the loaded YAML data.
@@ -367,7 +361,7 @@ def _list_dynamic_types_from_document(
     return rv
 
 
-def load_document(content: str) -> tuple[ResolveableType, CustomTypeRegistry]:
+def load_document(content: str) -> tuple[DocumentRootType, CustomTypeRegistry]:
     """Load a QType YAML file, validate it, and return the resolved root."""
     yaml_data = load_yaml(content)
     dynamic_types_lists = _list_dynamic_types_from_document(yaml_data)

qtype/semantic/generate.py

@@ -2,6 +2,7 @@ import argparse
 import inspect
 import subprocess
 from pathlib import Path
+from textwrap import dedent
 from typing import Any, Literal, Union, get_args, get_origin
 
 import networkx as nx
@@ -14,6 +15,7 @@ TYPES_TO_IGNORE = {
     "CustomType",
     "DecoderFormat",
     "Document",
+    "Flow",
     "PrimitiveTypeEnum",
     "StrictBaseModel",
     "StructuralTypeEnum",
@@ -37,7 +39,7 @@ def sort_classes_by_inheritance(
     classes: list[tuple[str, type]],
 ) -> list[tuple[str, type]]:
     """Sort classes based on their inheritance hierarchy."""
-    graph = nx.DiGraph()
+    graph: nx.DiGraph = nx.DiGraph()
     class_dict = dict(classes)
 
     # Build dependency graph
@@ -90,62 +92,109 @@ def generate_semantic_model(args: argparse.Namespace) -> None:
     # Write to output file
     with open(output_path, "w") as f:
         # Write header
-        f.write('"""\n')
-        f.write("Semantic Intermediate Representation models.\n\n")
         f.write(
-            "This module contains the semantic models that represent a resolved QType\n"
-        )
-        f.write(
-            "specification where all ID references have been replaced with actual object\n"
-        )
-        f.write("references.\n\n")
-        f.write(
-            "Generated automatically with command:\nqtype generate semantic-model\n"
+            dedent('''
+            """
+            Semantic Intermediate Representation models.
+
+            This module contains the semantic models that represent a resolved QType
+            specification where all ID references have been replaced with actual object
+            references.
+
+            Generated automatically with command:
+            qtype generate semantic-model
+
+            Types are ignored since they should reflect dsl directly, which is type checked.
+            """
+
+        ''').lstrip()
         )
-        f.write('"""\n\n')
 
         # Write imports
-        f.write("from __future__ import annotations\n\n")
-        f.write("from typing import Any, Type, Literal\n\n")
-        f.write("from pydantic import BaseModel, Field\n\n")
-        f.write("# Import enums and type aliases from DSL\n")
-        f.write(
-            "from qtype.dsl.model import CustomType, VariableType # noqa: F401\n"
-        )
         f.write(
-            "from qtype.dsl.model import ArrayTypeDefinition, DecoderFormat, PrimitiveTypeEnum, ObjectTypeDefinition, StructuralTypeEnum\n"
+            dedent("""
+            from __future__ import annotations
+
+            from typing import Any, Literal
+
+            from pydantic import BaseModel, Field, model_validator
+
+            # Import enums and type aliases from DSL
+            from qtype.dsl.model import VariableType  # noqa: F401
+            from qtype.dsl.model import (  # noqa: F401
+                CustomType,
+                DecoderFormat,
+                PrimitiveTypeEnum,
+                StepCardinality,
+                StructuralTypeEnum,
+            )
+            from qtype.dsl.model import Variable as DSLVariable  # noqa: F401
+            from qtype.semantic.base_types import ImmutableModel
+
+        """).lstrip()
         )
-        f.write(
-            "from qtype.dsl.model import Variable as DSLVariable # noqa: F401\n"
-        )
-        f.write("from qtype.semantic.base_types import ImmutableModel\n")
 
         # Write the new variable class
-        f.write("class Variable(DSLVariable, BaseModel):\n")
         f.write(
-            '    """Semantic version of DSL Variable with ID references resolved."""\n'
+            dedent('''
+            class Variable(DSLVariable, BaseModel):
+                """Semantic version of DSL Variable with ID references resolved."""
+                value: Any | None = Field(None, description="The value of the variable")
+                def is_set(self) -> bool:
+                    return self.value is not None
+
+        ''').lstrip()
         )
-        f.write(
-            '    value: Any | None = Field(None, description="The value of the variable")\n'
-        )
-        f.write("    def is_set(self) -> bool:\n")
-        f.write("        return self.value is not None\n")
 
         # Write classes
         f.write("\n\n".join(generated))
+
+        # Write the Flow class which _could_ be generated but we want a validator to update it's carndiality
         f.write("\n\n")
+        f.write(
+            dedent('''
+            class Flow(Step):
+                """Defines a flow of steps that can be executed in sequence or parallel.
+                If input or output variables are not specified, they are inferred from
+                the first and last step, respectively.
+                """
+
+                description: str | None = Field(
+                    None, description="Optional description of the flow."
+                )
+                cardinality: StepCardinality = Field(
+                    StepCardinality.auto,
+                    description="The cardinality of the flow, inferred from its steps when set to 'auto'.",
+                )
+                mode: Literal["Complete", "Chat"] = Field("Complete")
+                steps: list[Step] = Field(..., description="List of steps or step IDs.")
+
+                @model_validator(mode="after")
+                def infer_cardinality(self) -> "Flow":
+                    if self.cardinality == StepCardinality.auto:
+                        self.cardinality = StepCardinality.one
+                        for step in self.steps:
+                            if step.cardinality == StepCardinality.many:
+                                self.cardinality = StepCardinality.many
+                                break
+                    return self
+
+        ''').lstrip()
+        )
 
     # Format the file with Ruff
     format_with_ruff(str(output_path))
 
 
 def format_with_ruff(file_path: str) -> None:
-    """Format the given file using Ruff."""
-    try:
-        subprocess.run(["ruff", "check", "--fix", file_path], check=True)
-        subprocess.run(["ruff", "format", file_path], check=True)
-    except subprocess.CalledProcessError as e:
-        print(f"Error while formatting with Ruff: {e}")
+    """Format the given file using Ruff and isort to match pre-commit configuration."""
+    # Apply the same formatting as pre-commit but only to the specific file
+    # Use --force-exclude to match pre-commit behavior exactly
+    subprocess.run(["ruff", "check", "--fix", file_path], check=True)
+    subprocess.run(
+        ["ruff", "format", "--force-exclude", file_path], check=True
+    )
+    subprocess.run(["isort", file_path], check=True)
 
 
 DSL_ONLY_UNION_TYPES = {
@@ -246,10 +295,10 @@ def dsl_to_semantic_type_name(field_type: Any) -> str:
     if hasattr(field_type, "__name__"):
         type_name = field_type.__name__
         if _is_dsl_type(field_type) and type_name not in TYPES_TO_IGNORE:
-            return type_name
+            return str(type_name)
         if type_name == "NoneType":
             return "None"
-        return type_name
+        return str(type_name)
 
     return str(field_type)
 
@@ -284,6 +333,9 @@ def generate_semantic_class(class_name: str, cls: type) -> str:
                 inheritance = f"ABC, {semantic_base}"
             else:
                 inheritance = semantic_base
+            if semantic_name == "Tool":
+                # Tools should inherit from Step and be immutable
+                inheritance = f"{semantic_base}, ImmutableModel"
             break
 
     # Get field information from the class - only fields defined on this class, not inherited

qtype/semantic/model.py

@@ -7,17 +7,25 @@ references.
 
 Generated automatically with command:
 qtype generate semantic-model
+
+Types are ignored since they should reflect dsl directly, which is type checked.
 """
 
 from __future__ import annotations
 
 from typing import Any, Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 # Import enums and type aliases from DSL
 from qtype.dsl.model import VariableType  # noqa: F401
-from qtype.dsl.model import CustomType, DecoderFormat  # noqa: F401
+from qtype.dsl.model import (  # noqa: F401
+    CustomType,
+    DecoderFormat,
+    PrimitiveTypeEnum,
+    StepCardinality,
+    StructuralTypeEnum,
+)
 from qtype.dsl.model import Variable as DSLVariable  # noqa: F401
 from qtype.semantic.base_types import ImmutableModel
 
@@ -31,6 +39,15 @@ class Variable(DSLVariable, BaseModel):
         return self.value is not None
 
 
+class AuthorizationProvider(ImmutableModel):
+    """Base class for authentication providers."""
+
+    id: str = Field(
+        ..., description="Unique ID of the authorization configuration."
+    )
+    type: str = Field(..., description="Authorization method type.")
+
+
 class Application(BaseModel):
     """Defines a complete QType application specification.
 
@@ -61,8 +78,11 @@ class Application(BaseModel):
     flows: list[Flow] = Field(
         [], description="List of flows defined in this application."
     )
-    auths: list[AuthorizationProvider] = Field(
-        [], description="List of authorization providers used for API access."
+    auths: list[APIKeyAuthProvider | AWSAuthProvider | OAuth2AuthProvider] = (
+        Field(
+            [],
+            description="List of authorization providers used for API access.",
+        )
     )
     tools: list[Tool] = Field(
         [], description="List of tools available in this application."
@@ -75,33 +95,14 @@ class Application(BaseModel):
     )
 
 
-class AuthorizationProvider(ImmutableModel):
-    """Defines how tools or providers authenticate with APIs, such as OAuth2 or API keys."""
-
-    id: str = Field(
-        ..., description="Unique ID of the authorization configuration."
-    )
-    api_key: str | None = Field(
-        None, description="API key if using token-based auth."
-    )
-    client_id: str | None = Field(None, description="OAuth2 client ID.")
-    client_secret: str | None = Field(
-        None, description="OAuth2 client secret."
-    )
-    host: str | None = Field(
-        None, description="Base URL or domain of the provider."
-    )
-    scopes: list[str] = Field([], description="OAuth2 scopes required.")
-    token_url: str | None = Field(None, description="Token endpoint URL.")
-    type: str = Field(
-        ..., description="Authorization method, e.g., 'oauth2' or 'api_key'."
-    )
-
-
 class Step(BaseModel):
     """Base class for components that take inputs and produce outputs."""
 
     id: str = Field(..., description="Unique ID of this component.")
+    cardinality: StepCardinality = Field(
+        StepCardinality.one,
+        description="Does this step emit 1 (one) or 0...N (many) instances of the outputs?",
+    )
     inputs: list[Variable] = Field(
         [], description="Input variables required by this step."
     )
@@ -118,8 +119,10 @@ class Index(ImmutableModel):
         {},
         description="Index-specific configuration and connection parameters.",
     )
-    auth: AuthorizationProvider | None = Field(
-        None, description="AuthorizationProvider for accessing the index."
+    auth: APIKeyAuthProvider | AWSAuthProvider | OAuth2AuthProvider | None = (
+        Field(
+            None, description="AuthorizationProvider for accessing the index."
+        )
     )
     name: str = Field(..., description="Name of the index/collection/table.")
 
@@ -128,8 +131,8 @@ class Model(ImmutableModel):
     """Describes a generative model configuration, including provider and model ID."""
 
     id: str = Field(..., description="Unique ID for the model.")
-    auth: AuthorizationProvider | None = Field(
-        None, description="AuthorizationProvider used for model access."
+    auth: APIKeyAuthProvider | AWSAuthProvider | OAuth2AuthProvider | None = (
+        Field(None, description="AuthorizationProvider used for model access.")
     )
     inference_params: dict[str, Any] = Field(
         {},
@@ -166,15 +169,63 @@ class TelemetrySink(BaseModel):
     id: str = Field(
         ..., description="Unique ID of the telemetry sink configuration."
     )
-    auth: AuthorizationProvider | None = Field(
-        None,
-        description="AuthorizationProvider used to authenticate telemetry data transmission.",
+    auth: APIKeyAuthProvider | AWSAuthProvider | OAuth2AuthProvider | None = (
+        Field(
+            None,
+            description="AuthorizationProvider used to authenticate telemetry data transmission.",
+        )
     )
     endpoint: str = Field(
         ..., description="URL endpoint where telemetry data will be sent."
     )
 
 
+class APIKeyAuthProvider(AuthorizationProvider):
+    """API key-based authentication provider."""
+
+    type: Literal["api_key"] = Field("api_key")
+    api_key: str = Field(..., description="API key for authentication.")
+    host: str | None = Field(
+        None, description="Base URL or domain of the provider."
+    )
+
+
+class AWSAuthProvider(AuthorizationProvider):
+    """AWS authentication provider supporting multiple credential methods."""
+
+    type: Literal["aws"] = Field("aws")
+    access_key_id: str | None = Field(None, description="AWS access key ID.")
+    secret_access_key: str | None = Field(
+        None, description="AWS secret access key."
+    )
+    session_token: str | None = Field(
+        None, description="AWS session token for temporary credentials."
+    )
+    profile_name: str | None = Field(
+        None, description="AWS profile name from credentials file."
+    )
+    role_arn: str | None = Field(
+        None, description="ARN of the role to assume."
+    )
+    role_session_name: str | None = Field(
+        None, description="Session name for role assumption."
+    )
+    external_id: str | None = Field(
+        None, description="External ID for role assumption."
+    )
+    region: str | None = Field(None, description="AWS region.")
+
+
+class OAuth2AuthProvider(AuthorizationProvider):
+    """OAuth2 authentication provider."""
+
+    type: Literal["oauth2"] = Field("oauth2")
+    client_id: str = Field(..., description="OAuth2 client ID.")
+    client_secret: str = Field(..., description="OAuth2 client secret.")
+    token_url: str = Field(..., description="Token endpoint URL.")
+    scopes: list[str] = Field([], description="OAuth2 scopes required.")
+
+
 class Condition(Step):
     """Conditional logic gate within a flow. Supports branching logic for execution based on variable values."""
 
@@ -202,19 +253,6 @@ class Decoder(Step):
     )
 
 
-class Flow(Step):
-    """Defines a flow of steps that can be executed in sequence or parallel.
-    If input or output variables are not specified, they are inferred from
-    the first and last step, respectively.
-    """
-
-    description: str | None = Field(
-        None, description="Optional description of the flow."
-    )
-    mode: Literal["Complete", "Chat"] = Field("Complete")
-    steps: list[Step] = Field(..., description="List of steps or step IDs.")
-
-
 class LLMInference(Step):
     """Defines a step that performs inference using a language model.
     It can take input variables and produce output variables based on the model's response."""
@@ -251,7 +289,27 @@ class Search(Step):
     )
 
 
-class Tool(Step):
+class Sink(Step):
+    """Base class for data sinks"""
+
+    id: str = Field(..., description="Unique ID of the data sink.")
+    cardinality: Literal["one"] = Field(
+        StepCardinality.one,
+        description="Flows always emit exactly one instance of the outputs.",
+    )
+
+
+class Source(Step):
+    """Base class for data sources"""
+
+    id: str = Field(..., description="Unique ID of the data source.")
+    cardinality: Literal["many"] = Field(
+        StepCardinality.many,
+        description="Sources always emit 0...N instances of the outputs.",
+    )
+
+
+class Tool(Step, ImmutableModel):
     """
     Base class for callable functions or external operations available to the model or as a step in a flow.
     """
@@ -304,11 +362,55 @@ class VectorSearch(Search):
     """Performs vector similarity search against a vector index."""
 
     default_top_k: int | None = Field(
-        ...,
+        50,
         description="Number of top results to retrieve if not provided in the inputs.",
     )
 
 
+class IndexUpsert(Sink):
+    """Semantic version of IndexUpsert."""
+
+    index: Index = Field(
+        ..., description="Index to upsert into (object or ID reference)."
+    )
+
+
+class SQLSource(Source):
+    """SQL database source that executes queries and emits rows."""
+
+    query: str = Field(
+        ..., description="SQL query to execute. Inputs are injected as params."
+    )
+    connection: str = Field(
+        ...,
+        description="Database connection string or reference to auth provider. Typically in SQLAlchemy format.",
+    )
+    auth: APIKeyAuthProvider | AWSAuthProvider | OAuth2AuthProvider | None = (
+        Field(
+            None,
+            description="Optional AuthorizationProvider for database authentication.",
+        )
+    )
+
+
+class SourceType(Source):
+    """SQL database source that executes queries and emits rows."""
+
+    query: str = Field(
+        ..., description="SQL query to execute. Inputs are injected as params."
+    )
+    connection: str = Field(
+        ...,
+        description="Database connection string or reference to auth provider. Typically in SQLAlchemy format.",
+    )
+    auth: APIKeyAuthProvider | AWSAuthProvider | OAuth2AuthProvider | None = (
+        Field(
+            None,
+            description="Optional AuthorizationProvider for database authentication.",
+        )
+    )
+
+
 class APITool(Tool):
     """Tool that invokes an API endpoint."""
 
@@ -316,9 +418,11 @@ class APITool(Tool):
     method: str = Field(
         "GET", description="HTTP method to use (GET, POST, PUT, DELETE, etc.)."
     )
-    auth: AuthorizationProvider | None = Field(
-        None,
-        description="Optional AuthorizationProvider for API authentication.",
+    auth: APIKeyAuthProvider | AWSAuthProvider | OAuth2AuthProvider | None = (
+        Field(
+            None,
+            description="Optional AuthorizationProvider for API authentication.",
+        )
     )
     headers: dict[str, str] = Field(
         {}, description="Optional HTTP headers to include in the request."
@@ -334,3 +438,30 @@ class PythonFunctionTool(Tool):
     module_path: str = Field(
         ..., description="Optional module path where the function is defined."
     )
+
+
+class Flow(Step):
+    """Defines a flow of steps that can be executed in sequence or parallel.
+    If input or output variables are not specified, they are inferred from
+    the first and last step, respectively.
+    """
+
+    description: str | None = Field(
+        None, description="Optional description of the flow."
+    )
+    cardinality: StepCardinality = Field(
+        StepCardinality.auto,
+        description="The cardinality of the flow, inferred from its steps when set to 'auto'.",
+    )
+    mode: Literal["Complete", "Chat"] = Field("Complete")
+    steps: list[Step] = Field(..., description="List of steps or step IDs.")
+
+    @model_validator(mode="after")
+    def infer_cardinality(self) -> "Flow":
+        if self.cardinality == StepCardinality.auto:
+            self.cardinality = StepCardinality.one
+            for step in self.steps:
+                if step.cardinality == StepCardinality.many:
+                    self.cardinality = StepCardinality.many
+                    break
+        return self

qtype/semantic/resolver.py

@@ -11,9 +11,9 @@ from typing import Any
 
 import qtype.dsl.domain_types
 import qtype.dsl.model as dsl
+import qtype.semantic.model as ir
+from qtype.base.exceptions import SemanticError
 from qtype.dsl.validator import _is_dsl_type, _resolve_forward_ref
-from qtype.semantic import model as ir
-from qtype.semantic.errors import SemanticResolutionError
 
 logger = logging.getLogger(__name__)
 
@@ -53,7 +53,7 @@ def to_semantic_ir(
         class_name = dslobj.__class__.__name__
         ir_class = getattr(ir, class_name, None)
         if not ir_class:
-            raise SemanticResolutionError(
+            raise SemanticError(
                 f"Could not find Semantic class for DSL type: {class_name}"
             )
         # iterate over the parameters of the DSL object and convert them to their semantic IR equivalents.
@@ -90,7 +90,7 @@ def resolve(application: dsl.Application) -> ir.Application:
     # references to actual objects.
     result = to_semantic_ir(application, {})
     if not isinstance(result, ir.Application):
-        raise SemanticResolutionError(
+        raise SemanticError(
             "The root object must be an Application, but got: "
             f"{type(result).__name__}"
         )