ai-pipeline-core 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

ai_pipeline_core/__init__.py

@@ -27,12 +27,12 @@ from .logging import (
 )
 from .logging import get_pipeline_logger as get_logger
 from .pipeline import pipeline_flow, pipeline_task
-from .prefect import flow, task
+from .prefect import disable_run_logger, prefect_test_harness
 from .prompt_manager import PromptManager
 from .settings import settings
 from .tracing import TraceInfo, TraceLevel, trace
 
-__version__ = "0.1.7"
+__version__ = "0.1.8"
 
 __all__ = [
     # Config/Settings
@@ -54,12 +54,12 @@ __all__ = [
     # Flow/Task
     "FlowConfig",
     "FlowOptions",
-    # Prefect decorators (clean, no tracing)
-    "task",
-    "flow",
     # Pipeline decorators (with tracing)
     "pipeline_task",
     "pipeline_flow",
+    # Prefect decorators (clean, no tracing)
+    "prefect_test_harness",
+    "disable_run_logger",
     # LLM
     "llm",
     "ModelName",

ai_pipeline_core/documents/document.py

@@ -26,12 +26,27 @@ TModel = TypeVar("TModel", bound=BaseModel)
 
 
 class Document(BaseModel, ABC):
-    """Abstract base class for all documents"""
+    """Abstract base class for all documents.
+
+    Warning: Document subclasses should NOT start with 'Test' prefix as this
+    causes conflicts with pytest test discovery. Classes with 'Test' prefix
+    will be rejected at definition time.
+    """
 
     MAX_CONTENT_SIZE: ClassVar[int] = 25 * 1024 * 1024  # 25MB default
     DESCRIPTION_EXTENSION: ClassVar[str] = ".description.md"
     MARKDOWN_LIST_SEPARATOR: ClassVar[str] = "\n\n---\n\n"
 
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        """Validate subclass names to prevent pytest conflicts."""
+        super().__init_subclass__(**kwargs)
+        if cls.__name__.startswith("Test"):
+            raise TypeError(
+                f"Document subclass '{cls.__name__}' cannot start with 'Test' prefix. "
+                "This causes conflicts with pytest test discovery. "
+                "Please use a different name (e.g., 'SampleDocument', 'ExampleDocument')."
+            )
+
     def __init__(self, **data: Any) -> None:
         """Prevent direct instantiation of abstract Document class."""
         if type(self) is Document:

ai_pipeline_core/flow/config.py

@@ -14,6 +14,27 @@ class FlowConfig(ABC):
     INPUT_DOCUMENT_TYPES: ClassVar[list[type[FlowDocument]]]
     OUTPUT_DOCUMENT_TYPE: ClassVar[type[FlowDocument]]
 
+    def __init_subclass__(cls, **kwargs):
+        """Validate that OUTPUT_DOCUMENT_TYPE is not in INPUT_DOCUMENT_TYPES."""
+        super().__init_subclass__(**kwargs)
+
+        # Skip validation for the abstract base class itself
+        if cls.__name__ == "FlowConfig":
+            return
+
+        # Ensure required attributes are defined
+        if not hasattr(cls, "INPUT_DOCUMENT_TYPES"):
+            raise TypeError(f"FlowConfig {cls.__name__} must define INPUT_DOCUMENT_TYPES")
+        if not hasattr(cls, "OUTPUT_DOCUMENT_TYPE"):
+            raise TypeError(f"FlowConfig {cls.__name__} must define OUTPUT_DOCUMENT_TYPE")
+
+        # Validate that output type is not in input types
+        if cls.OUTPUT_DOCUMENT_TYPE in cls.INPUT_DOCUMENT_TYPES:
+            raise TypeError(
+                f"FlowConfig {cls.__name__}: OUTPUT_DOCUMENT_TYPE "
+                f"({cls.OUTPUT_DOCUMENT_TYPE.__name__}) cannot be in INPUT_DOCUMENT_TYPES"
+            )
+
     @classmethod
     def get_input_document_types(cls) -> list[type[FlowDocument]]:
         """

ai_pipeline_core/llm/model_options.py

@@ -4,6 +4,7 @@ from pydantic import BaseModel
 
 
 class ModelOptions(BaseModel):
+    temperature: float | None = None
     system_prompt: str | None = None
     search_context_size: Literal["low", "medium", "high"] | None = None
     reasoning_effort: Literal["low", "medium", "high"] | None = None
@@ -21,6 +22,9 @@ class ModelOptions(BaseModel):
             "extra_body": {},
         }
 
+        if self.temperature:
+            kwargs["temperature"] = self.temperature
+
         if self.max_completion_tokens:
             kwargs["max_completion_tokens"] = self.max_completion_tokens
 

ai_pipeline_core/pipeline.py

@@ -1,397 +1,395 @@
-"""Pipeline decorators that combine Prefect functionality with tracing support.
+"""
+ai_pipeline_core.pipeline
+=========================
+
+Tiny wrappers around Prefect's public ``@task`` and ``@flow`` that add our
+``trace`` decorator and **require async functions**.
+
+Why this exists
+---------------
+Prefect tasks/flows are awaitable at runtime, but their public type stubs
+don’t declare that clearly. We therefore:
+
+1) Return the **real Prefect objects** (so you keep every Prefect method).
+2) Type them as small Protocols that say “this is awaitable and has common
+   helpers like `.submit`/`.map`”.
 
-These decorators extend the base Prefect decorators with automatic tracing capabilities.
+This keeps Pyright happy without altering runtime behavior and avoids
+leaking advanced typing constructs (like ``ParamSpec``) that confuse tools
+that introspect callables (e.g., Pydantic).
+
+Quick start
+-----------
+from ai_pipeline_core.pipeline import pipeline_task, pipeline_flow
+from ai_pipeline_core.documents import DocumentList
+from ai_pipeline_core.flow.options import FlowOptions
+
+@pipeline_task
+async def add(x: int, y: int) -> int:
+    return x + y
+
+@pipeline_flow
+async def my_flow(project_name: str, docs: DocumentList, opts: FlowOptions) -> DocumentList:
+    await add(1, 2)  # awaitable and typed
+    return docs
+
+Rules
+-----
+• Your decorated function **must** be ``async def``.
+• ``@pipeline_flow`` functions must accept at least:
+  (project_name: str, documents: DocumentList, flow_options: FlowOptions | subclass).
+• Both wrappers return the same Prefect objects you’d get from Prefect directly.
 """
 
+from __future__ import annotations
+
 import datetime
-import functools
 import inspect
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Coroutine,
-    Dict,
-    Iterable,
-    Optional,
-    TypeVar,
-    Union,
-    cast,
-    overload,
-)
+from typing import Any, Callable, Coroutine, Iterable, Protocol, TypeVar, Union, cast, overload
 
 from prefect.assets import Asset
 from prefect.cache_policies import CachePolicy
 from prefect.context import TaskRunContext
-from prefect.flows import Flow, FlowStateHook
+from prefect.flows import FlowStateHook
+from prefect.flows import flow as _prefect_flow  # public import
 from prefect.futures import PrefectFuture
 from prefect.results import ResultSerializer, ResultStorage
 from prefect.task_runners import TaskRunner
-from prefect.tasks import (
-    RetryConditionCallable,
-    StateHookCallable,
-    Task,
-    TaskRunNameValueOrCallable,
-)
+from prefect.tasks import task as _prefect_task  # public import
 from prefect.utilities.annotations import NotSet
-from typing_extensions import Concatenate, ParamSpec
+from typing_extensions import TypeAlias
 
 from ai_pipeline_core.documents import DocumentList
 from ai_pipeline_core.flow.options import FlowOptions
-from ai_pipeline_core.prefect import flow, task
 from ai_pipeline_core.tracing import TraceLevel, trace
 
-if TYPE_CHECKING:
-    pass
+# --------------------------------------------------------------------------- #
+# Public callback aliases (Prefect stubs omit these exact types)
+# --------------------------------------------------------------------------- #
+RetryConditionCallable: TypeAlias = Callable[[Any, Any, Any], bool]
+StateHookCallable: TypeAlias = Callable[[Any, Any, Any], None]
+TaskRunNameValueOrCallable: TypeAlias = Union[str, Callable[[], str]]
 
-P = ParamSpec("P")
-R = TypeVar("R")
+# --------------------------------------------------------------------------- #
+# Typing helpers
+# --------------------------------------------------------------------------- #
+R_co = TypeVar("R_co", covariant=True)
+FO_contra = TypeVar("FO_contra", bound=FlowOptions, contravariant=True)
+"""Flow options are an *input* type, so contravariant fits the callable model."""
 
-# ============================================================================
-# PIPELINE TASK DECORATOR
-# ============================================================================
 
+class _TaskLike(Protocol[R_co]):
+    """Minimal 'task-like' view: awaitable call + common helpers."""
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Coroutine[Any, Any, R_co]: ...
+
+    submit: Callable[..., Any]
+    map: Callable[..., Any]
+    name: str | None
+
+    def __getattr__(self, name: str) -> Any: ...  # allow unknown helpers without type errors
 
-@overload
-def pipeline_task(__fn: Callable[P, R], /) -> Task[P, R]: ...
 
+class _DocumentsFlowCallable(Protocol[FO_contra]):
+    """User async flow signature (first three params fixed)."""
 
+    def __call__(
+        self,
+        project_name: str,
+        documents: DocumentList,
+        flow_options: FO_contra,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Coroutine[Any, Any, DocumentList]: ...
+
+
+class _FlowLike(Protocol[FO_contra]):
+    """Callable returned by Prefect ``@flow`` wrapper that we expose to users."""
+
+    def __call__(
+        self,
+        project_name: str,
+        documents: DocumentList,
+        flow_options: FO_contra,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Coroutine[Any, Any, DocumentList]: ...
+
+    name: str | None
+
+    def __getattr__(self, name: str) -> Any: ...  # allow unknown helpers without type errors
+
+
+# --------------------------------------------------------------------------- #
+# Small helper: safely get a callable's name without upsetting the type checker
+# --------------------------------------------------------------------------- #
+def _callable_name(obj: Any, fallback: str) -> str:
+    try:
+        n = getattr(obj, "__name__", None)
+        return n if isinstance(n, str) else fallback
+    except Exception:
+        return fallback
+
+
+# --------------------------------------------------------------------------- #
+# @pipeline_task — async-only, traced, returns Prefect's Task object
+# --------------------------------------------------------------------------- #
+@overload
+def pipeline_task(__fn: Callable[..., Coroutine[Any, Any, R_co]], /) -> _TaskLike[R_co]: ...
 @overload
 def pipeline_task(
     *,
-    # Tracing parameters
+    # tracing
     trace_level: TraceLevel = "always",
     trace_ignore_input: bool = False,
     trace_ignore_output: bool = False,
     trace_ignore_inputs: list[str] | None = None,
-    trace_input_formatter: Optional[Callable[..., str]] = None,
-    trace_output_formatter: Optional[Callable[..., str]] = None,
-    # Prefect parameters
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    tags: Optional[Iterable[str]] = None,
-    version: Optional[str] = None,
-    cache_policy: Union[CachePolicy, type[NotSet]] = NotSet,
-    cache_key_fn: Optional[Callable[[TaskRunContext, Dict[str, Any]], Optional[str]]] = None,
-    cache_expiration: Optional[datetime.timedelta] = None,
-    task_run_name: Optional[TaskRunNameValueOrCallable] = None,
-    retries: Optional[int] = None,
-    retry_delay_seconds: Optional[
-        Union[float, int, list[float], Callable[[int], list[float]]]
-    ] = None,
-    retry_jitter_factor: Optional[float] = None,
-    persist_result: Optional[bool] = None,
-    result_storage: Optional[Union[ResultStorage, str]] = None,
-    result_serializer: Optional[Union[ResultSerializer, str]] = None,
-    result_storage_key: Optional[str] = None,
+    trace_input_formatter: Callable[..., str] | None = None,
+    trace_output_formatter: Callable[..., str] | None = None,
+    # prefect passthrough
+    name: str | None = None,
+    description: str | None = None,
+    tags: Iterable[str] | None = None,
+    version: str | None = None,
+    cache_policy: CachePolicy | type[NotSet] = NotSet,
+    cache_key_fn: Callable[[TaskRunContext, dict[str, Any]], str | None] | None = None,
+    cache_expiration: datetime.timedelta | None = None,
+    task_run_name: TaskRunNameValueOrCallable | None = None,
+    retries: int | None = None,
+    retry_delay_seconds: int | float | list[float] | Callable[[int], list[float]] | None = None,
+    retry_jitter_factor: float | None = None,
+    persist_result: bool | None = None,
+    result_storage: ResultStorage | str | None = None,
+    result_serializer: ResultSerializer | str | None = None,
+    result_storage_key: str | None = None,
     cache_result_in_memory: bool = True,
-    timeout_seconds: Union[int, float, None] = None,
-    log_prints: Optional[bool] = False,
-    refresh_cache: Optional[bool] = None,
-    on_completion: Optional[list[StateHookCallable]] = None,
-    on_failure: Optional[list[StateHookCallable]] = None,
-    retry_condition_fn: Optional[RetryConditionCallable] = None,
-    viz_return_value: Optional[bool] = None,
-    asset_deps: Optional[list[Union[str, Asset]]] = None,
-) -> Callable[[Callable[P, R]], Task[P, R]]: ...
+    timeout_seconds: int | float | None = None,
+    log_prints: bool | None = False,
+    refresh_cache: bool | None = None,
+    on_completion: list[StateHookCallable] | None = None,
+    on_failure: list[StateHookCallable] | None = None,
+    retry_condition_fn: RetryConditionCallable | None = None,
+    viz_return_value: bool | None = None,
+    asset_deps: list[str | Asset] | None = None,
+) -> Callable[[Callable[..., Coroutine[Any, Any, R_co]]], _TaskLike[R_co]]: ...
 
 
 def pipeline_task(
-    __fn: Optional[Callable[P, R]] = None,
+    __fn: Callable[..., Coroutine[Any, Any, R_co]] | None = None,
     /,
     *,
-    # Tracing parameters
+    # tracing
     trace_level: TraceLevel = "always",
     trace_ignore_input: bool = False,
     trace_ignore_output: bool = False,
     trace_ignore_inputs: list[str] | None = None,
-    trace_input_formatter: Optional[Callable[..., str]] = None,
-    trace_output_formatter: Optional[Callable[..., str]] = None,
-    # Prefect parameters
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    tags: Optional[Iterable[str]] = None,
-    version: Optional[str] = None,
-    cache_policy: Union[CachePolicy, type[NotSet]] = NotSet,
-    cache_key_fn: Optional[Callable[[TaskRunContext, Dict[str, Any]], Optional[str]]] = None,
-    cache_expiration: Optional[datetime.timedelta] = None,
-    task_run_name: Optional[TaskRunNameValueOrCallable] = None,
-    retries: Optional[int] = None,
-    retry_delay_seconds: Optional[
-        Union[float, int, list[float], Callable[[int], list[float]]]
-    ] = None,
-    retry_jitter_factor: Optional[float] = None,
-    persist_result: Optional[bool] = None,
-    result_storage: Optional[Union[ResultStorage, str]] = None,
-    result_serializer: Optional[Union[ResultSerializer, str]] = None,
-    result_storage_key: Optional[str] = None,
+    trace_input_formatter: Callable[..., str] | None = None,
+    trace_output_formatter: Callable[..., str] | None = None,
+    # prefect passthrough
+    name: str | None = None,
+    description: str | None = None,
+    tags: Iterable[str] | None = None,
+    version: str | None = None,
+    cache_policy: CachePolicy | type[NotSet] = NotSet,
+    cache_key_fn: Callable[[TaskRunContext, dict[str, Any]], str | None] | None = None,
+    cache_expiration: datetime.timedelta | None = None,
+    task_run_name: TaskRunNameValueOrCallable | None = None,
+    retries: int | None = None,
+    retry_delay_seconds: int | float | list[float] | Callable[[int], list[float]] | None = None,
+    retry_jitter_factor: float | None = None,
+    persist_result: bool | None = None,
+    result_storage: ResultStorage | str | None = None,
+    result_serializer: ResultSerializer | str | None = None,
+    result_storage_key: str | None = None,
     cache_result_in_memory: bool = True,
-    timeout_seconds: Union[int, float, None] = None,
-    log_prints: Optional[bool] = False,
-    refresh_cache: Optional[bool] = None,
-    on_completion: Optional[list[StateHookCallable]] = None,
-    on_failure: Optional[list[StateHookCallable]] = None,
-    retry_condition_fn: Optional[RetryConditionCallable] = None,
-    viz_return_value: Optional[bool] = None,
-    asset_deps: Optional[list[Union[str, Asset]]] = None,
-) -> Union[Task[P, R], Callable[[Callable[P, R]], Task[P, R]]]:
-    """
-    Pipeline task decorator that combines Prefect task functionality with automatic tracing.
-
-    This decorator applies tracing before the Prefect task decorator, allowing you to
-    monitor task execution with LMNR while maintaining all Prefect functionality.
-
-    Args:
-        trace_level: Control tracing ("always", "debug", "off")
-        trace_ignore_input: Whether to ignore input in traces
-        trace_ignore_output: Whether to ignore output in traces
-        trace_ignore_inputs: List of input parameter names to ignore
-        trace_input_formatter: Custom formatter for inputs
-        trace_output_formatter: Custom formatter for outputs
+    timeout_seconds: int | float | None = None,
+    log_prints: bool | None = False,
+    refresh_cache: bool | None = None,
+    on_completion: list[StateHookCallable] | None = None,
+    on_failure: list[StateHookCallable] | None = None,
+    retry_condition_fn: RetryConditionCallable | None = None,
+    viz_return_value: bool | None = None,
+    asset_deps: list[str | Asset] | None = None,
+) -> _TaskLike[R_co] | Callable[[Callable[..., Coroutine[Any, Any, R_co]]], _TaskLike[R_co]]:
+    """Decorate an **async** function as a traced Prefect task."""
+    task_decorator: Callable[..., Any] = _prefect_task  # helps the type checker
+
+    def _apply(fn: Callable[..., Coroutine[Any, Any, R_co]]) -> _TaskLike[R_co]:
+        if not inspect.iscoroutinefunction(fn):
+            raise TypeError(
+                f"@pipeline_task target '{_callable_name(fn, 'task')}' must be 'async def'"
+            )
 
-        Plus all standard Prefect task parameters...
-    """
+        traced_fn = trace(
+            level=trace_level,
+            name=name or _callable_name(fn, "task"),
+            ignore_input=trace_ignore_input,
+            ignore_output=trace_ignore_output,
+            ignore_inputs=trace_ignore_inputs,
+            input_formatter=trace_input_formatter,
+            output_formatter=trace_output_formatter,
+        )(fn)
 
-    def decorator(fn: Callable[P, R]) -> Task[P, R]:
-        # Apply tracing first if enabled
-        if trace_level != "off":
-            traced_fn = trace(
-                level=trace_level,
-                name=name or fn.__name__,
-                ignore_input=trace_ignore_input,
-                ignore_output=trace_ignore_output,
-                ignore_inputs=trace_ignore_inputs,
-                input_formatter=trace_input_formatter,
-                output_formatter=trace_output_formatter,
-            )(fn)
-        else:
-            traced_fn = fn
-
-        # Then apply Prefect task decorator
-        return task(  # pyright: ignore[reportCallIssue,reportUnknownVariableType]
-            traced_fn,  # pyright: ignore[reportArgumentType]
-            name=name,
-            description=description,
-            tags=tags,
-            version=version,
-            cache_policy=cache_policy,
-            cache_key_fn=cache_key_fn,
-            cache_expiration=cache_expiration,
-            task_run_name=task_run_name,
-            retries=retries or 0,
-            retry_delay_seconds=retry_delay_seconds,
-            retry_jitter_factor=retry_jitter_factor,
-            persist_result=persist_result,
-            result_storage=result_storage,
-            result_serializer=result_serializer,
-            result_storage_key=result_storage_key,
-            cache_result_in_memory=cache_result_in_memory,
-            timeout_seconds=timeout_seconds,
-            log_prints=log_prints,
-            refresh_cache=refresh_cache,
-            on_completion=on_completion,
-            on_failure=on_failure,
-            retry_condition_fn=retry_condition_fn,
-            viz_return_value=viz_return_value,
-            asset_deps=asset_deps,
+        return cast(
+            _TaskLike[R_co],
+            task_decorator(
+                name=name,
+                description=description,
+                tags=tags,
+                version=version,
+                cache_policy=cache_policy,
+                cache_key_fn=cache_key_fn,
+                cache_expiration=cache_expiration,
+                task_run_name=task_run_name,
+                retries=0 if retries is None else retries,
+                retry_delay_seconds=retry_delay_seconds,
+                retry_jitter_factor=retry_jitter_factor,
+                persist_result=persist_result,
+                result_storage=result_storage,
+                result_serializer=result_serializer,
+                result_storage_key=result_storage_key,
+                cache_result_in_memory=cache_result_in_memory,
+                timeout_seconds=timeout_seconds,
+                log_prints=log_prints,
+                refresh_cache=refresh_cache,
+                on_completion=on_completion,
+                on_failure=on_failure,
+                retry_condition_fn=retry_condition_fn,
+                viz_return_value=viz_return_value,
+                asset_deps=asset_deps,
+            )(traced_fn),
         )
 
-    if __fn:
-        return decorator(__fn)
-    return decorator
-
-
-# ============================================================================
-# PIPELINE FLOW DECORATOR WITH DOCUMENT PROCESSING
-# ============================================================================
-
-# Type aliases for document flow signatures
-DocumentsFlowSig = Callable[
-    Concatenate[str, DocumentList, FlowOptions, P],
-    Union[DocumentList, Coroutine[Any, Any, DocumentList]],
-]
-
-DocumentsFlowResult = Flow[Concatenate[str, DocumentList, FlowOptions, P], DocumentList]
+    return _apply(__fn) if __fn else _apply
 
 
+# --------------------------------------------------------------------------- #
+# @pipeline_flow — async-only, traced, returns Prefect’s flow wrapper
+# --------------------------------------------------------------------------- #
 @overload
-def pipeline_flow(
-    __fn: DocumentsFlowSig[P],
-    /,
-) -> DocumentsFlowResult[P]: ...
-
-
+def pipeline_flow(__fn: _DocumentsFlowCallable[FO_contra], /) -> _FlowLike[FO_contra]: ...
 @overload
 def pipeline_flow(
     *,
-    # Tracing parameters
+    # tracing
     trace_level: TraceLevel = "always",
     trace_ignore_input: bool = False,
     trace_ignore_output: bool = False,
     trace_ignore_inputs: list[str] | None = None,
-    trace_input_formatter: Optional[Callable[..., str]] = None,
-    trace_output_formatter: Optional[Callable[..., str]] = None,
-    # Prefect parameters
-    name: Optional[str] = None,
-    version: Optional[str] = None,
-    flow_run_name: Optional[Union[Callable[[], str], str]] = None,
-    retries: Optional[int] = None,
-    retry_delay_seconds: Optional[Union[int, float]] = None,
-    task_runner: Optional[TaskRunner[PrefectFuture[Any]]] = None,
-    description: Optional[str] = None,
-    timeout_seconds: Union[int, float, None] = None,
+    trace_input_formatter: Callable[..., str] | None = None,
+    trace_output_formatter: Callable[..., str] | None = None,
+    # prefect passthrough
+    name: str | None = None,
+    version: str | None = None,
+    flow_run_name: Union[Callable[[], str], str] | None = None,
+    retries: int | None = None,
+    retry_delay_seconds: int | float | None = None,
+    task_runner: TaskRunner[PrefectFuture[Any]] | None = None,
+    description: str | None = None,
+    timeout_seconds: int | float | None = None,
     validate_parameters: bool = True,
-    persist_result: Optional[bool] = None,
-    result_storage: Optional[Union[ResultStorage, str]] = None,
-    result_serializer: Optional[Union[ResultSerializer, str]] = None,
+    persist_result: bool | None = None,
+    result_storage: ResultStorage | str | None = None,
+    result_serializer: ResultSerializer | str | None = None,
     cache_result_in_memory: bool = True,
-    log_prints: Optional[bool] = None,
-    on_completion: Optional[list["FlowStateHook[..., Any]"]] = None,
-    on_failure: Optional[list["FlowStateHook[..., Any]"]] = None,
-    on_cancellation: Optional[list["FlowStateHook[..., Any]"]] = None,
-    on_crashed: Optional[list["FlowStateHook[..., Any]"]] = None,
-    on_running: Optional[list["FlowStateHook[..., Any]"]] = None,
-) -> Callable[[DocumentsFlowSig[P]], DocumentsFlowResult[P]]: ...
+    log_prints: bool | None = None,
+    on_completion: list[FlowStateHook[Any, Any]] | None = None,
+    on_failure: list[FlowStateHook[Any, Any]] | None = None,
+    on_cancellation: list[FlowStateHook[Any, Any]] | None = None,
+    on_crashed: list[FlowStateHook[Any, Any]] | None = None,
+    on_running: list[FlowStateHook[Any, Any]] | None = None,
+) -> Callable[[_DocumentsFlowCallable[FO_contra]], _FlowLike[FO_contra]]: ...
 
 
 def pipeline_flow(
-    __fn: Optional[DocumentsFlowSig[P]] = None,
+    __fn: _DocumentsFlowCallable[FO_contra] | None = None,
     /,
     *,
-    # Tracing parameters
+    # tracing
     trace_level: TraceLevel = "always",
     trace_ignore_input: bool = False,
     trace_ignore_output: bool = False,
     trace_ignore_inputs: list[str] | None = None,
-    trace_input_formatter: Optional[Callable[..., str]] = None,
-    trace_output_formatter: Optional[Callable[..., str]] = None,
-    # Prefect parameters
-    name: Optional[str] = None,
-    version: Optional[str] = None,
-    flow_run_name: Optional[Union[Callable[[], str], str]] = None,
-    retries: Optional[int] = None,
-    retry_delay_seconds: Optional[Union[int, float]] = None,
-    task_runner: Optional[TaskRunner[PrefectFuture[Any]]] = None,
-    description: Optional[str] = None,
-    timeout_seconds: Union[int, float, None] = None,
+    trace_input_formatter: Callable[..., str] | None = None,
+    trace_output_formatter: Callable[..., str] | None = None,
+    # prefect passthrough
+    name: str | None = None,
+    version: str | None = None,
+    flow_run_name: Union[Callable[[], str], str] | None = None,
+    retries: int | None = None,
+    retry_delay_seconds: int | float | None = None,
+    task_runner: TaskRunner[PrefectFuture[Any]] | None = None,
+    description: str | None = None,
+    timeout_seconds: int | float | None = None,
     validate_parameters: bool = True,
-    persist_result: Optional[bool] = None,
-    result_storage: Optional[Union[ResultStorage, str]] = None,
-    result_serializer: Optional[Union[ResultSerializer, str]] = None,
+    persist_result: bool | None = None,
+    result_storage: ResultStorage | str | None = None,
+    result_serializer: ResultSerializer | str | None = None,
     cache_result_in_memory: bool = True,
-    log_prints: Optional[bool] = None,
-    on_completion: Optional[list["FlowStateHook[..., Any]"]] = None,
-    on_failure: Optional[list["FlowStateHook[..., Any]"]] = None,
-    on_cancellation: Optional[list["FlowStateHook[..., Any]"]] = None,
-    on_crashed: Optional[list["FlowStateHook[..., Any]"]] = None,
-    on_running: Optional[list["FlowStateHook[..., Any]"]] = None,
-) -> Union[DocumentsFlowResult[P], Callable[[DocumentsFlowSig[P]], DocumentsFlowResult[P]]]:
-    """
-    Pipeline flow for document processing with standardized signature.
-
-    This decorator enforces a specific signature for document processing flows:
-    - First parameter: project_name (str)
-    - Second parameter: documents (DocumentList)
-    - Third parameter: flow_options (FlowOptions or subclass)
-    - Additional parameters allowed
-    - Must return DocumentList
-
-    It includes automatic tracing and all Prefect flow functionality.
-
-    Args:
-        trace_level: Control tracing ("always", "debug", "off")
-        trace_ignore_input: Whether to ignore input in traces
-        trace_ignore_output: Whether to ignore output in traces
-        trace_ignore_inputs: List of input parameter names to ignore
-        trace_input_formatter: Custom formatter for inputs
-        trace_output_formatter: Custom formatter for outputs
-
-        Plus all standard Prefect flow parameters...
+    log_prints: bool | None = None,
+    on_completion: list[FlowStateHook[Any, Any]] | None = None,
+    on_failure: list[FlowStateHook[Any, Any]] | None = None,
+    on_cancellation: list[FlowStateHook[Any, Any]] | None = None,
+    on_crashed: list[FlowStateHook[Any, Any]] | None = None,
+    on_running: list[FlowStateHook[Any, Any]] | None = None,
+) -> _FlowLike[FO_contra] | Callable[[_DocumentsFlowCallable[FO_contra]], _FlowLike[FO_contra]]:
+    """Decorate an **async** flow.
+
+    Required signature:
+        async def flow_fn(
+            project_name: str,
+            documents: DocumentList,
+            flow_options: FlowOptions,  # or any subclass
+            *args,
+            **kwargs
+        ) -> DocumentList
+
+    Returns the same callable object Prefect’s ``@flow`` would return.
     """
+    flow_decorator: Callable[..., Any] = _prefect_flow
 
-    def decorator(func: DocumentsFlowSig[P]) -> DocumentsFlowResult[P]:
-        sig = inspect.signature(func)
-        params = list(sig.parameters.values())
+    def _apply(fn: _DocumentsFlowCallable[FO_contra]) -> _FlowLike[FO_contra]:
+        fname = _callable_name(fn, "flow")
 
-        if len(params) < 3:
+        if not inspect.iscoroutinefunction(fn):
+            raise TypeError(f"@pipeline_flow '{fname}' must be declared with 'async def'")
+        if len(inspect.signature(fn).parameters) < 3:
             raise TypeError(
-                f"@pipeline_flow '{func.__name__}' must accept at least 3 arguments: "
-                "(project_name, documents, flow_options)"
+                f"@pipeline_flow '{fname}' must accept "
+                "'project_name, documents, flow_options' as its first three parameters"
             )
 
-        # Validate parameter types (optional but recommended)
-        # We check names as a convention, not strict type checking at decoration time
-        expected_names = ["project_name", "documents", "flow_options"]
-        for i, expected in enumerate(expected_names):
-            if i < len(params) and params[i].name != expected:
-                print(
-                    f"Warning: Parameter {i + 1} of '{func.__name__}' is named '{params[i].name}' "
-                    f"but convention suggests '{expected}'"
+        async def _wrapper(
+            project_name: str,
+            documents: DocumentList,
+            flow_options: FO_contra,
+            *args: Any,
+            **kwargs: Any,
+        ) -> DocumentList:
+            result = await fn(project_name, documents, flow_options, *args, **kwargs)
+            if not isinstance(result, DocumentList):  # pyright: ignore[reportUnnecessaryIsInstance]
+                raise TypeError(
+                    f"Flow '{fname}' must return DocumentList, got {type(result).__name__}"
                 )
+            return result
+
+        traced = trace(
+            level=trace_level,
+            name=name or fname,
+            ignore_input=trace_ignore_input,
+            ignore_output=trace_ignore_output,
+            ignore_inputs=trace_ignore_inputs,
+            input_formatter=trace_input_formatter,
+            output_formatter=trace_output_formatter,
+        )(_wrapper)
 
-        # Create wrapper that ensures return type
-        if inspect.iscoroutinefunction(func):
-
-            @functools.wraps(func)
-            async def wrapper(  # pyright: ignore[reportRedeclaration]
-                project_name: str,
-                documents: DocumentList,
-                flow_options: FlowOptions,
-                *args,  # pyright: ignore[reportMissingParameterType]
-                **kwargs,  # pyright: ignore[reportMissingParameterType]
-            ) -> DocumentList:
-                result = await func(project_name, documents, flow_options, *args, **kwargs)
-                # Runtime type checking
-                DL = DocumentList  # Avoid recomputation
-                if not isinstance(result, DL):
-                    raise TypeError(
-                        f"Flow '{func.__name__}' must return a DocumentList, "
-                        f"but returned {type(result).__name__}"
-                    )
-                return result
-        else:
-
-            @functools.wraps(func)
-            def wrapper(  # pyright: ignore[reportRedeclaration]
-                project_name: str,
-                documents: DocumentList,
-                flow_options: FlowOptions,
-                *args,  # pyright: ignore[reportMissingParameterType]
-                **kwargs,  # pyright: ignore[reportMissingParameterType]
-            ) -> DocumentList:
-                result = func(project_name, documents, flow_options, *args, **kwargs)
-                # Runtime type checking
-                DL = DocumentList  # Avoid recomputation
-                if not isinstance(result, DL):
-                    raise TypeError(
-                        f"Flow '{func.__name__}' must return a DocumentList, "
-                        f"but returned {type(result).__name__}"
-                    )
-                return result
-
-        # Apply tracing first if enabled
-        if trace_level != "off":
-            traced_wrapper = trace(
-                level=trace_level,
-                name=name or func.__name__,
-                ignore_input=trace_ignore_input,
-                ignore_output=trace_ignore_output,
-                ignore_inputs=trace_ignore_inputs,
-                input_formatter=trace_input_formatter,
-                output_formatter=trace_output_formatter,
-            )(wrapper)
-        else:
-            traced_wrapper = wrapper
-
-        # Then apply Prefect flow decorator
         return cast(
-            DocumentsFlowResult[P],
-            flow(  # pyright: ignore[reportCallIssue,reportUnknownVariableType]
-                traced_wrapper,  # pyright: ignore[reportArgumentType]
+            _FlowLike[FO_contra],
+            flow_decorator(
                 name=name,
                 version=version,
                 flow_run_name=flow_run_name,
-                retries=retries,
+                retries=0 if retries is None else retries,
                 retry_delay_seconds=retry_delay_seconds,
                 task_runner=task_runner,
                 description=description,
@@ -407,12 +405,10 @@ def pipeline_flow(
                 on_cancellation=on_cancellation,
                 on_crashed=on_crashed,
                 on_running=on_running,
-            ),
+            )(traced),
         )
 
-    if __fn:
-        return decorator(__fn)
-    return decorator
+    return _apply(__fn) if __fn else _apply
 
 
 __all__ = ["pipeline_task", "pipeline_flow"]

ai_pipeline_core/simple_runner/cli.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import os
+import sys
+from contextlib import ExitStack
 from pathlib import Path
 from typing import Callable, Type, TypeVar, cast
 
@@ -10,6 +13,8 @@ from pydantic_settings import CliPositionalArg, SettingsConfigDict
 from ai_pipeline_core.documents import DocumentList
 from ai_pipeline_core.flow.options import FlowOptions
 from ai_pipeline_core.logging import get_pipeline_logger, setup_logging
+from ai_pipeline_core.prefect import disable_run_logger, prefect_test_harness
+from ai_pipeline_core.settings import settings
 
 from .simple_runner import ConfigSequence, FlowSequence, run_pipelines, save_documents_to_directory
 
@@ -28,12 +33,18 @@ def _initialize_environment() -> None:
         logger.warning(f"Failed to initialize LMNR tracing: {e}")
 
 
+def _running_under_pytest() -> bool:  # NEW
+    """Return True when invoked by pytest (so fixtures will supply test contexts)."""
+    return "PYTEST_CURRENT_TEST" in os.environ or "pytest" in sys.modules
+
+
 def run_cli(
     *,
     flows: FlowSequence,
     flow_configs: ConfigSequence,
     options_cls: Type[TOptions],
     initializer: InitializerFunc = None,
+    trace_name: str | None = None,
 ) -> None:
     """
     Parse CLI+env into options, then run the pipeline.
@@ -43,13 +54,20 @@ def run_cli(
     - --start/--end: optional, 1-based step bounds
     - all other flags come from options_cls (fields & Field descriptions)
     """
+    # Check if no arguments provided before initialization
+    if len(sys.argv) == 1:
+        # Add --help to show usage
+        sys.argv.append("--help")
+
     _initialize_environment()
 
     class _RunnerOptions(  # type: ignore[reportRedeclaration]
         options_cls,
         cli_parse_args=True,
         cli_kebab_case=True,
-        cli_exit_on_error=False,
+        cli_exit_on_error=True,  # Let it exit normally on error
+        cli_prog_name="ai-pipeline",
+        cli_use_class_docs_for_groups=True,
     ):
         working_directory: CliPositionalArg[Path]
         project_name: str | None = None
@@ -82,14 +100,28 @@ def run_cli(
         if getattr(opts, "start", 1) == 1 and initial_documents:
             save_documents_to_directory(wd, initial_documents)
 
-    asyncio.run(
-        run_pipelines(
-            project_name=project_name,
-            output_dir=wd,
-            flows=flows,
-            flow_configs=flow_configs,
-            flow_options=opts,
-            start_step=getattr(opts, "start", 1),
-            end_step=getattr(opts, "end", None),
+    # Setup context stack with optional test harness and tracing
+
+    with ExitStack() as stack:
+        if not settings.prefect_api_key and not _running_under_pytest():
+            stack.enter_context(prefect_test_harness())
+            stack.enter_context(disable_run_logger())
+
+        if trace_name:
+            stack.enter_context(
+                Laminar.start_span(
+                    name=f"{trace_name}-{project_name}", input=[opts.model_dump_json()]
+                )
+            )
+
+        asyncio.run(
+            run_pipelines(
+                project_name=project_name,
+                output_dir=wd,
+                flows=flows,
+                flow_configs=flow_configs,
+                flow_options=opts,
+                start_step=getattr(opts, "start", 1),
+                end_step=getattr(opts, "end", None),
+            )
         )
-    )

{ai_pipeline_core-0.1.7.dist-info → ai_pipeline_core-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-pipeline-core
-Version: 0.1.7
+Version: 0.1.8
 Summary: Core utilities for AI-powered processing pipelines using prefect
 Project-URL: Homepage, https://github.com/bbarwik/ai-pipeline-core
 Project-URL: Repository, https://github.com/bbarwik/ai-pipeline-core
@@ -151,7 +151,7 @@ async def process_document(doc: Document):
     return response.parsed
 ```
 
-### Enhanced Pipeline Decorators (New in v0.1.7)
+### Enhanced Pipeline Decorators
 ```python
 from ai_pipeline_core import pipeline_flow, pipeline_task
 from ai_pipeline_core.flow import FlowOptions
@@ -182,7 +182,7 @@ async def my_pipeline(
     return DocumentList(results)
 ```
 
-### Simple Runner Utility (New in v0.1.7)
+### Simple Runner Utility
 ```python
 from ai_pipeline_core.simple_runner import run_cli, run_pipeline
 from ai_pipeline_core.flow import FlowOptions
@@ -206,7 +206,7 @@ async def main():
     )
 ```
 
-### Clean Prefect Decorators (New in v0.1.7)
+### Clean Prefect Decorators
 ```python
 # Import clean Prefect decorators without tracing
 from ai_pipeline_core.prefect import flow, task
@@ -214,12 +214,12 @@ from ai_pipeline_core.prefect import flow, task
 # Or use pipeline decorators with tracing
 from ai_pipeline_core import pipeline_flow, pipeline_task
 
-@task  # Clean Prefect task
+@task  # Clean Prefect task (supports both sync and async)
 def compute(x: int) -> int:
     return x * 2
 
-@pipeline_task(trace_level="always")  # With tracing
-def compute_traced(x: int) -> int:
+@pipeline_task(trace_level="always")  # With tracing (async only)
+async def compute_traced(x: int) -> int:
     return x * 2
 ```
 
@@ -246,12 +246,12 @@ docs = DocumentList([doc1, doc2])
 Managed AI interactions with built-in retry logic, cost tracking, and structured outputs.
 
 **Supported Models** (via LiteLLM proxy):
-- OpenAI: GPT-4, GPT-5 series
-- Anthropic: Claude 3 series
-- Google: Gemini 2.5 series
-- xAI: Grok models
-- Perplexity: Sonar models (with search capabilities)
-- And many more through LiteLLM compatibility
+- OpenAI: gpt-5
+- Anthropic: claude-4
+- Google: gemini-2.5
+- xAI: grok-3, grok-4
+- Perplexity: sonar-pro-search
+- And many more through LiteLLM compatibility. Every model from openrouter should work.
 
 ```python
 from ai_pipeline_core.llm import generate_structured, AIMessages, ModelOptions
@@ -328,13 +328,13 @@ ai_pipeline_core/
 │   └── model_options.py # Configuration models
 ├── flow/              # Prefect flow utilities
 │   ├── config.py      # Type-safe flow configuration
-│   └── options.py     # FlowOptions base class (v0.1.7)
-├── simple_runner/     # Pipeline execution utilities (v0.1.7)
+│   └── options.py     # FlowOptions base class
+├── simple_runner/     # Pipeline execution utilities
 │   ├── cli.py         # CLI interface
 │   └── simple_runner.py # Core runner logic
 ├── logging/           # Structured logging
-├── pipeline.py        # Enhanced decorators (v0.1.7)
-├── prefect.py         # Clean Prefect exports (v0.1.7)
+├── pipeline.py        # Enhanced decorators
+├── prefect.py         # Clean Prefect exports
 ├── tracing.py         # Observability decorators
 └── settings.py        # Centralized configuration
 ```
@@ -345,6 +345,7 @@ ai_pipeline_core/
 ```bash
 make test           # Run all tests
 make test-cov      # Run with coverage report
+make test-showcase # Test the showcase.py CLI example
 pytest tests/test_documents.py::TestDocument::test_creation  # Single test
 ```
 
@@ -481,6 +482,22 @@ For learning purposes, see [CLAUDE.md](CLAUDE.md) for our comprehensive coding s
 
 - [CLAUDE.md](CLAUDE.md) - Detailed coding standards and architecture guide
 
+## Examples
+
+### In This Repository
+- [showcase.py](examples/showcase.py) - Complete example demonstrating all core features including the CLI runner
+  ```bash
+  # Run the showcase example with CLI
+  python examples/showcase.py ./output --temperature 0.7 --batch-size 5
+
+  # Show help
+  python examples/showcase.py --help
+  ```
+- [showcase.jinja2](examples/showcase.jinja2) - Example Jinja2 prompt template
+
+### Real-World Application
+- [AI Documentation Writer](https://github.com/bbarwik/ai-documentation-writer) - Production-ready example showing how to build sophisticated AI pipelines for automated documentation generation. See [examples/ai-documentation-writer.md](examples/ai-documentation-writer.md) for a detailed overview.
+
 ### dependencies_docs/ Directory
 > [!NOTE]
 > The `dependencies_docs/` directory contains guides for AI assistants (like Claude Code) on how to interact with the project's external dependencies and tooling, NOT user documentation for ai-pipeline-core itself. These files are excluded from repository listings to avoid confusion.
@@ -511,29 +528,29 @@ Built with:
 - [LiteLLM](https://litellm.ai/) - LLM proxy
 - [Pydantic](https://pydantic-docs.helpmanual.io/) - Data validation
 
-## What's New in v0.1.7
+## What's New in v0.1.8
 
-### Major Additions
-- **Enhanced Pipeline Decorators**: New `pipeline_flow` and `pipeline_task` decorators combining Prefect functionality with automatic LMNR tracing
-- **FlowOptions Base Class**: Extensible configuration system for flows with type-safe inheritance
-- **Simple Runner Module**: CLI and programmatic utilities for easy pipeline execution
-- **Clean Prefect Exports**: Separate imports for Prefect decorators with and without tracing
-- **Expanded Exports**: All major components now accessible from top-level package import
+### Breaking Changes
+- **Async-Only Pipeline Decorators**: `@pipeline_flow` and `@pipeline_task` now require `async def` functions (raises TypeError for sync)
+- **Document Class Name Validation**: Document subclasses cannot start with "Test" prefix (pytest conflict prevention)
+- **FlowConfig Validation**: OUTPUT_DOCUMENT_TYPE cannot be in INPUT_DOCUMENT_TYPES (prevents circular dependencies)
+- **Temperature Field**: Added optional `temperature` field to `ModelOptions` for explicit control
 
-### API Improvements
-- Better type inference for document flows with custom options
-- Support for custom FlowOptions inheritance in pipeline flows
-- Improved error messages for invalid flow signatures
-- Enhanced document utility functions (`canonical_name_key`, `sanitize_url`)
+### Major Improvements
+- **Pipeline Module Refactoring**: Reduced from ~400 to ~150 lines with cleaner Protocol-based typing
+- **Enhanced Validation**: FlowConfig and Document classes now validate at definition time
+- **Better CLI Support**: Auto-displays help when no arguments provided, improved context management
+- **Test Suite Updates**: All tests updated to use async/await consistently
 
-### Developer Experience
-- Simplified imports - most components available from `ai_pipeline_core` directly
-- Better separation of concerns between clean Prefect and traced pipeline decorators
-- More intuitive flow configuration with `FlowOptions` inheritance
+### Documentation Updates
+- Added Document naming rules to CLAUDE.md
+- Added FlowConfig validation rules
+- Added code elegance principles section
+- Updated guide_for_ai.md to API reference format
 
 ## Stability Notice
 
-**Current Version**: 0.1.7
+**Current Version**: 0.1.8
 **Status**: Internal Preview
 **API Stability**: Unstable - Breaking changes expected
 **Recommended Use**: Learning and reference only

{ai_pipeline_core-0.1.7.dist-info → ai_pipeline_core-0.1.8.dist-info}/RECORD

@@ -1,25 +1,25 @@
-ai_pipeline_core/__init__.py,sha256=INcTtHr2TFY8bR0eCg7RwvIRYY6px8knCgjyIvSSKP4,1602
+ai_pipeline_core/__init__.py,sha256=dWkrDbW3oqrplHH7oBQ59dOc0wtJr0AcKVtQo63C_wM,1662
 ai_pipeline_core/exceptions.py,sha256=_vW0Hbw2LGb5tcVvH0YzTKMff7QOPfCRr3w-w_zPyCE,968
-ai_pipeline_core/pipeline.py,sha256=GOrPC53j756Xhpg_CShnkAKxSdkC16XHEoPeIhkjLIA,16569
+ai_pipeline_core/pipeline.py,sha256=f-pEDwrEhMLfcSEvPP2b74xb0WzFI05IQcl-NDFzH7w,16565
 ai_pipeline_core/prefect.py,sha256=VHYkkRcUmSpdwyWosOOxuExVCncIQgT6MypqGdjcYnM,241
 ai_pipeline_core/prompt_manager.py,sha256=XmNUdMIC0WrE9fF0LIcfozAKOGrlYwj8AfXvCndIH-o,4693
 ai_pipeline_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ai_pipeline_core/settings.py,sha256=Zl2BPa6IHzh-B5V7cg5mtySr1dhWZQYYKxXz3BwrHlQ,615
 ai_pipeline_core/tracing.py,sha256=T-3fTyA37TejXxotkVzTNqL2a5nOfZ0bcHg9TClLvmg,9471
 ai_pipeline_core/documents/__init__.py,sha256=TLW8eOEmthfDHOTssXjyBlqhgrZe9ZIyxlkd0LBJ3_s,340
-ai_pipeline_core/documents/document.py,sha256=e3IBr0TThucBAaOHvdqv0X--iCcBrqh2jzFTyaOp7O0,12418
+ai_pipeline_core/documents/document.py,sha256=AIdkg2RIyYB5Tje1GmnQqtk8qesOIQwtwzEztypYIhg,13121
 ai_pipeline_core/documents/document_list.py,sha256=HOG_uZDazA9CJB7Lr_tNcDFzb5Ff9RUt0ELWQK_eYNM,4940
 ai_pipeline_core/documents/flow_document.py,sha256=qsV-2JYOMhkvAj7lW54ZNH_4QUclld9h06CoU59tWww,815
 ai_pipeline_core/documents/mime_type.py,sha256=sBhNRoBJQ35JoHWhJzBGpp00WFDfMdEX0JZKKkR7QH0,3371
 ai_pipeline_core/documents/task_document.py,sha256=WjHqtl1d60XFBBqewNRdz1OqBErGI0jRx15oQYCTHo8,907
 ai_pipeline_core/documents/utils.py,sha256=BdE4taSl1vrBhxnFbOP5nDA7lXIcvY__AMRTHoaNb5M,2764
 ai_pipeline_core/flow/__init__.py,sha256=54DRfZnjXQVrimgtKEVEm5u5ErImx31cjK2PpBvHjU4,116
-ai_pipeline_core/flow/config.py,sha256=crbe_OvNE6qulIKv1D8yKoe8xrEsIlvICyxjhqHHBxQ,2266
+ai_pipeline_core/flow/config.py,sha256=gRCtiahTA7h6_xVPY3su85pZbu5gu41yXUgGLILey2E,3220
 ai_pipeline_core/flow/options.py,sha256=WygJEwjqOa14l23a_Hp36hJX-WgxHMq-YzSieC31Z4Y,701
 ai_pipeline_core/llm/__init__.py,sha256=3XVK-bSJdOe0s6KmmO7PDbsXHfjlcZEG1MVBmaz3EeU,442
 ai_pipeline_core/llm/ai_messages.py,sha256=DwJJe05BtYdnMZeHbBbyEbDCqrW63SRvprxptoJUCn4,4586
 ai_pipeline_core/llm/client.py,sha256=VMs1nQKCfoxbcvE2mypn5QF19u90Ua87-5IiZxWOj98,7784
-ai_pipeline_core/llm/model_options.py,sha256=TvAAlDFZN-TP9-J-RZBuU_dpSocskf6paaQMw1XY9UE,1321
+ai_pipeline_core/llm/model_options.py,sha256=7O5y-qtYtmTXzIUS7vxKOQlRAM3TTggqHw2_dOnS_a8,1441
 ai_pipeline_core/llm/model_response.py,sha256=fIWueaemgo0cMruvToMZyKsRPzKwL6IlvUJN7DLG710,5558
 ai_pipeline_core/llm/model_types.py,sha256=rIwY6voT8-xdfsKPDC0Gkdl2iTp9Q2LuvWGSRU9Mp3k,342
 ai_pipeline_core/logging/__init__.py,sha256=DOO6ckgnMVXl29Sy7q6jhO-iW96h54pCHQDzgA2Pu6I,272
@@ -27,9 +27,9 @@ ai_pipeline_core/logging/logging.yml,sha256=YTW48keO_K5bkkb-KXGM7ZuaYKiquLsjsURe
 ai_pipeline_core/logging/logging_config.py,sha256=6MBz9nnVNvqiLDoyy9-R3sWkn6927Re5hdz4hwTptpI,4903
 ai_pipeline_core/logging/logging_mixin.py,sha256=RDaR2ju2-vKTJRzXGa0DquGPT8_UxahWjvKJnaD0IV8,7810
 ai_pipeline_core/simple_runner/__init__.py,sha256=OPbTCZvqpnYdwi1Knnkj-MpmD0Nvtg5O7UwIdAKz_AY,384
-ai_pipeline_core/simple_runner/cli.py,sha256=TjiSh7lr1VnTbO1jA2DuVzC2AA6V_5sA5Z8XSuldQmc,3054
+ai_pipeline_core/simple_runner/cli.py,sha256=1X2kkdsGFIewYMxtoRVDS1RY6cx5wNVEIw-TeShbLCc,4281
 ai_pipeline_core/simple_runner/simple_runner.py,sha256=70BHT1iz-G368H2t4tsWAVni0jw2VkWVdnKICuVtLPw,5009
-ai_pipeline_core-0.1.7.dist-info/METADATA,sha256=2Pi815TCTBlKnTp2duTaUJiKaextafqZ5yfPZdD_--o,18361
-ai_pipeline_core-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ai_pipeline_core-0.1.7.dist-info/licenses/LICENSE,sha256=kKj8mfbdWwkyG3U6n7ztB3bAZlEwShTkAsvaY657i3I,1074
-ai_pipeline_core-0.1.7.dist-info/RECORD,,
+ai_pipeline_core-0.1.8.dist-info/METADATA,sha256=RX8VUdE5M5DUE7S4LebGvnJkse87s23SxzxsDC7Rys4,19119
+ai_pipeline_core-0.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ai_pipeline_core-0.1.8.dist-info/licenses/LICENSE,sha256=kKj8mfbdWwkyG3U6n7ztB3bAZlEwShTkAsvaY657i3I,1074
+ai_pipeline_core-0.1.8.dist-info/RECORD,,