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

ai_pipeline_core/__init__.py

@@ -6,6 +6,7 @@ from .documents import (
     DocumentList,
     FlowDocument,
     TaskDocument,
+    TemporaryDocument,
     canonical_name_key,
     sanitize_url,
 )
@@ -32,7 +33,7 @@ from .prompt_manager import PromptManager
 from .settings import settings
 from .tracing import TraceInfo, TraceLevel, trace
 
-__version__ = "0.1.8"
+__version__ = "0.1.10"
 
 __all__ = [
     # Config/Settings
@@ -49,6 +50,7 @@ __all__ = [
     "DocumentList",
     "FlowDocument",
     "TaskDocument",
+    "TemporaryDocument",
     "canonical_name_key",
     "sanitize_url",
     # Flow/Task

ai_pipeline_core/documents/__init__.py

@@ -2,6 +2,7 @@ from .document import Document
 from .document_list import DocumentList
 from .flow_document import FlowDocument
 from .task_document import TaskDocument
+from .temporary_document import TemporaryDocument
 from .utils import canonical_name_key, sanitize_url
 
 __all__ = [
@@ -9,6 +10,7 @@ __all__ = [
     "DocumentList",
     "FlowDocument",
     "TaskDocument",
+    "TemporaryDocument",
     "canonical_name_key",
     "sanitize_url",
 ]

ai_pipeline_core/documents/document.py

@@ -6,7 +6,19 @@ from abc import ABC, abstractmethod
 from base64 import b32encode
 from enum import StrEnum
 from functools import cached_property
-from typing import Any, ClassVar, Literal, Self, TypeVar
+from io import BytesIO
+from typing import (
+    Any,
+    ClassVar,
+    Literal,
+    Self,
+    TypeVar,
+    cast,
+    final,
+    get_args,
+    get_origin,
+    overload,
+)
 
 from pydantic import BaseModel, ConfigDict, field_serializer, field_validator
 from ruamel.yaml import YAML
@@ -23,6 +35,7 @@ from .mime_type import (
 )
 
 TModel = TypeVar("TModel", bound=BaseModel)
+ContentInput = bytes | str | BaseModel | list[str] | Any
 
 
 class Document(BaseModel, ABC):
@@ -46,6 +59,22 @@ class Document(BaseModel, ABC):
                 "This causes conflicts with pytest test discovery. "
                 "Please use a different name (e.g., 'SampleDocument', 'ExampleDocument')."
             )
+        if hasattr(cls, "FILES"):
+            files = getattr(cls, "FILES")
+            if not issubclass(files, StrEnum):
+                raise TypeError(
+                    f"Document subclass '{cls.__name__}'.FILES must be an Enum of string values"
+                )
+        # Check that the Document's model_fields only contain the allowed fields
+        # It prevents AI models from adding additional fields to documents
+        allowed = {"name", "description", "content"}
+        current = set(getattr(cls, "model_fields", {}).keys())
+        extras = current - allowed
+        if extras:
+            raise TypeError(
+                f"Document subclass '{cls.__name__}' cannot declare additional fields: "
+                f"{', '.join(sorted(extras))}. Only {', '.join(sorted(allowed))} are allowed."
+            )
 
     def __init__(self, **data: Any) -> None:
         """Prevent direct instantiation of abstract Document class."""
@@ -53,49 +82,60 @@ class Document(BaseModel, ABC):
             raise TypeError("Cannot instantiate abstract Document class directly")
         super().__init__(**data)
 
-    # Optional enum of allowed file names. Subclasses may set this.
-    # This is used to validate the document name.
-    FILES: ClassVar[type[StrEnum] | None] = None
-
     name: str
     description: str | None = None
     content: bytes
 
     # Pydantic configuration
     model_config = ConfigDict(
-        frozen=True,  # Make documents immutable
+        frozen=True,
         arbitrary_types_allowed=True,
+        extra="forbid",
     )
 
     @abstractmethod
-    def get_base_type(self) -> Literal["flow", "task"]:
+    def get_base_type(self) -> Literal["flow", "task", "temporary"]:
         """Get the type of the document - must be implemented by subclasses"""
         raise NotImplementedError("Subclasses must implement this method")
 
+    @final
     @property
-    def base_type(self) -> Literal["flow", "task"]:
+    def base_type(self) -> Literal["flow", "task", "temporary"]:
         """Alias for document_type for backward compatibility"""
         return self.get_base_type()
 
+    @final
     @property
     def is_flow(self) -> bool:
         """Check if document is a flow document"""
         return self.get_base_type() == "flow"
 
+    @final
     @property
     def is_task(self) -> bool:
         """Check if document is a task document"""
         return self.get_base_type() == "task"
 
+    @final
+    @property
+    def is_temporary(self) -> bool:
+        """Check if document is a temporary document"""
+        return self.get_base_type() == "temporary"
+
+    @final
     @classmethod
     def get_expected_files(cls) -> list[str] | None:
         """
         Return the list of allowed file names for this document class, or None if unrestricted.
         """
-        if cls.FILES is None:
+        if not hasattr(cls, "FILES"):
             return None
+        files = getattr(cls, "FILES")
+        if not files:
+            return None
+        assert issubclass(files, StrEnum)
         try:
-            values = [member.value for member in cls.FILES]
+            values = [member.value for member in files]
         except TypeError:
             raise DocumentNameError(f"{cls.__name__}.FILES must be an Enum of string values")
         if len(values) == 0:
@@ -115,14 +155,10 @@ class Document(BaseModel, ABC):
         Override this method in subclasses for custom conventions (regex, prefixes, etc.).
         Raise DocumentNameError when invalid.
         """
-        if cls.FILES is None:
+        allowed = cls.get_expected_files()
+        if not allowed:
             return
 
-        try:
-            allowed = {str(member.value) for member in cls.FILES}  # type: ignore[arg-type]
-        except TypeError:
-            raise DocumentNameError(f"{cls.__name__}.FILES must be an Enum of string values")
-
         if len(allowed) > 0 and name not in allowed:
             allowed_str = ", ".join(sorted(allowed))
             raise DocumentNameError(f"Invalid filename '{name}'. Allowed names: {allowed_str}")
@@ -166,16 +202,19 @@ class Document(BaseModel, ABC):
             # Fall back to base64 for binary content
             return base64.b64encode(v).decode("ascii")
 
+    @final
     @property
     def id(self) -> str:
         """Return the first 6 characters of the SHA256 hash of the content, encoded in base32"""
         return self.sha256[:6]
 
+    @final
     @cached_property
     def sha256(self) -> str:
         """Full SHA256 hash of content, encoded in base32"""
         return b32encode(hashlib.sha256(self.content).digest()).decode("ascii").upper()
 
+    @final
     @property
     def size(self) -> int:
         """Size of content in bytes"""
@@ -225,23 +264,61 @@ class Document(BaseModel, ABC):
         """Parse document as JSON"""
         return json.loads(self.as_text())
 
-    def as_pydantic_model(self, model_type: type[TModel]) -> TModel:
+    @overload
+    def as_pydantic_model(self, model_type: type[TModel]) -> TModel: ...
+
+    @overload
+    def as_pydantic_model(self, model_type: type[list[TModel]]) -> list[TModel]: ...
+
+    def as_pydantic_model(
+        self, model_type: type[TModel] | type[list[TModel]]
+    ) -> TModel | list[TModel]:
         """Parse document as a pydantic model and return the validated instance"""
         data = self.as_yaml() if is_yaml_mime_type(self.mime_type) else self.as_json()
-        return model_type.model_validate(data)
+
+        if get_origin(model_type) is list:
+            if not isinstance(data, list):
+                raise ValueError(f"Expected list data for {model_type}, got {type(data)}")
+            item_type = get_args(model_type)[0]
+            return [item_type.model_validate(item) for item in data]
+
+        # At this point model_type must be type[TModel], not type[list[TModel]]
+        single_model = cast(type[TModel], model_type)
+        return single_model.model_validate(data)
 
     def as_markdown_list(self) -> list[str]:
         """Parse document as a markdown list"""
         return self.as_text().split(self.MARKDOWN_LIST_SEPARATOR)
 
+    @overload
+    @classmethod
+    def create(cls, name: str, content: ContentInput, /) -> Self: ...
+    @overload
+    @classmethod
+    def create(cls, name: str, *, content: ContentInput) -> Self: ...
+    @overload
+    @classmethod
+    def create(cls, name: str, description: str | None, content: ContentInput, /) -> Self: ...
+    @overload
+    @classmethod
+    def create(cls, name: str, description: str | None, *, content: ContentInput) -> Self: ...
+
     @classmethod
     def create(
         cls,
         name: str,
-        description: str | None,
-        content: bytes | str | BaseModel | list[str] | Any,
+        description: ContentInput = None,
+        content: ContentInput = None,
     ) -> Self:
         """Create a document from a name, description, and content"""
+        if content is None:
+            if description is None:
+                raise ValueError(f"Unsupported content type: {type(content)} for {name}")
+            content = description
+            description = None
+        else:
+            assert description is None or isinstance(description, str)
+
         is_yaml_extension = name.endswith(".yaml") or name.endswith(".yml")
         is_json_extension = name.endswith(".json")
         is_markdown_extension = name.endswith(".md")
@@ -252,6 +329,14 @@ class Document(BaseModel, ABC):
             content = content.encode("utf-8")
         elif is_str_list and is_markdown_extension:
             return cls.create_as_markdown_list(name, description, content)  # type: ignore[arg-type]
+        elif isinstance(content, list) and all(isinstance(item, BaseModel) for item in content):
+            # Handle list[BaseModel] for JSON/YAML files
+            if is_yaml_extension:
+                return cls.create_as_yaml(name, description, content)
+            elif is_json_extension:
+                return cls.create_as_json(name, description, content)
+            else:
+                raise ValueError(f"list[BaseModel] requires .json or .yaml extension, got {name}")
         elif is_yaml_extension:
             return cls.create_as_yaml(name, description, content)
         elif is_json_extension:
@@ -261,6 +346,7 @@ class Document(BaseModel, ABC):
 
         return cls(name=name, description=description, content=content)
 
+    @final
     @classmethod
     def create_as_markdown_list(cls, name: str, description: str | None, items: list[str]) -> Self:
         """Create a document from a name, description, and list of strings"""
@@ -273,15 +359,19 @@ class Document(BaseModel, ABC):
         content = Document.MARKDOWN_LIST_SEPARATOR.join(cleaned_items)
         return cls.create(name, description, content)
 
+    @final
     @classmethod
     def create_as_json(cls, name: str, description: str | None, data: Any) -> Self:
         """Create a document from a name, description, and JSON data"""
         assert name.endswith(".json"), f"Document name must end with .json: {name}"
         if isinstance(data, BaseModel):
             data = data.model_dump(mode="json")
+        elif isinstance(data, list) and all(isinstance(item, BaseModel) for item in data):
+            data = [item.model_dump(mode="json") for item in data]
         content = json.dumps(data, indent=2).encode("utf-8")
         return cls.create(name, description, content)
 
+    @final
     @classmethod
     def create_as_yaml(cls, name: str, description: str | None, data: Any) -> Self:
         """Create a document from a name, description, and YAML data"""
@@ -289,16 +379,18 @@ class Document(BaseModel, ABC):
             f"Document name must end with .yaml or .yml: {name}"
         )
         if isinstance(data, BaseModel):
-            data = data.model_dump()
+            data = data.model_dump(mode="json")
+        elif isinstance(data, list) and all(isinstance(item, BaseModel) for item in data):
+            data = [item.model_dump(mode="json") for item in data]
         yaml = YAML()
         yaml.indent(mapping=2, sequence=4, offset=2)
-        from io import BytesIO
 
         stream = BytesIO()
         yaml.dump(data, stream)
         content = stream.getvalue()
         return cls.create(name, description, content)
 
+    @final
     def serialize_model(self) -> dict[str, Any]:
         """Serialize document to a dictionary with proper encoding."""
         result = {
@@ -327,6 +419,7 @@ class Document(BaseModel, ABC):
 
         return result
 
+    @final
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
         """Deserialize document from dictionary."""

ai_pipeline_core/documents/temporary_document.py

@@ -0,0 +1,16 @@
+"""Task-specific document base class."""
+
+from typing import Literal, final
+
+from .document import Document
+
+
+@final
+class TemporaryDocument(Document):
+    """
+    Temporary document is a document that is not persisted in any case.
+    """
+
+    def get_base_type(self) -> Literal["temporary"]:
+        """Get the document type."""
+        return "temporary"

ai_pipeline_core/flow/config.py

@@ -1,7 +1,7 @@
 """Flow configuration base class."""
 
 from abc import ABC
-from typing import ClassVar
+from typing import Any, ClassVar
 
 from ai_pipeline_core.documents import DocumentList, FlowDocument
 
@@ -14,7 +14,7 @@ class FlowConfig(ABC):
     INPUT_DOCUMENT_TYPES: ClassVar[list[type[FlowDocument]]]
     OUTPUT_DOCUMENT_TYPE: ClassVar[type[FlowDocument]]
 
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: Any):
         """Validate that OUTPUT_DOCUMENT_TYPE is not in INPUT_DOCUMENT_TYPES."""
         super().__init_subclass__(**kwargs)
 
@@ -85,3 +85,21 @@ class FlowConfig(ABC):
             "Documents must be of the correct type. "
             f"Expected: {output_document_class.__name__}, Got invalid: {invalid}"
         )
+
+    @classmethod
+    def create_and_validate_output(
+        cls, output: FlowDocument | list[FlowDocument] | DocumentList
+    ) -> DocumentList:
+        """
+        Create the output documents for the flow.
+        """
+        documents: DocumentList
+        if isinstance(output, FlowDocument):
+            documents = DocumentList([output])
+        elif isinstance(output, DocumentList):
+            documents = output
+        else:
+            assert isinstance(output, list)
+            documents = DocumentList(output)  # type: ignore[arg-type]
+        cls.validate_output_documents(documents)
+        return documents

ai_pipeline_core/prompt_manager.py

@@ -5,7 +5,7 @@ import jinja2
 
 from ai_pipeline_core.logging import get_pipeline_logger
 
-from .exceptions import PromptNotFoundError, PromptRenderError
+from .exceptions import PromptError, PromptNotFoundError, PromptRenderError
 
 logger = get_pipeline_logger(__name__)
 
@@ -28,6 +28,12 @@ class PromptManager:
 
         # Start from the directory containing the calling file
         current_path = Path(current_dir).resolve()
+        if not current_path.exists():
+            raise PromptError(
+                f"PromptManager expected __file__ (a valid file path), "
+                f"but got {current_dir!r}. Did you pass __name__ instead?"
+            )
+
         if current_path.is_file():
             current_path = current_path.parent
 

ai_pipeline_core/simple_runner/cli.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from typing import Callable, Type, TypeVar, cast
 
 from lmnr import Laminar
+from pydantic import ValidationError
 from pydantic_settings import CliPositionalArg, SettingsConfigDict
 
 from ai_pipeline_core.documents import DocumentList
@@ -76,7 +77,49 @@ def run_cli(
 
         model_config = SettingsConfigDict(frozen=True, extra="ignore")
 
-    opts = cast(FlowOptions, _RunnerOptions())  # type: ignore[reportCallIssue]
+    try:
+        opts = cast(FlowOptions, _RunnerOptions())  # type: ignore[reportCallIssue]
+    except ValidationError as e:
+        print("\nError: Invalid command line arguments\n", file=sys.stderr)
+        for error in e.errors():
+            field = " -> ".join(str(loc) for loc in error["loc"])
+            msg = error["msg"]
+            value = error.get("input", "")
+
+            # Format the field name nicely (convert from snake_case to kebab-case for CLI)
+            cli_field = field.replace("_", "-")
+
+            print(f"  --{cli_field}: {msg}", file=sys.stderr)
+            if value:
+                print(f"    Provided value: '{value}'", file=sys.stderr)
+
+            # Add helpful hints for common errors
+            if error["type"] == "float_parsing":
+                print("    Hint: Please provide a valid number (e.g., 0.7)", file=sys.stderr)
+            elif error["type"] == "int_parsing":
+                print("    Hint: Please provide a valid integer (e.g., 10)", file=sys.stderr)
+            elif error["type"] == "literal_error":
+                ctx = error.get("ctx", {})
+                expected = ctx.get("expected", "valid options")
+                print(f"    Hint: Valid options are: {expected}", file=sys.stderr)
+            elif error["type"] in [
+                "less_than_equal",
+                "greater_than_equal",
+                "less_than",
+                "greater_than",
+            ]:
+                ctx = error.get("ctx", {})
+                if "le" in ctx:
+                    print(f"    Hint: Value must be ≤ {ctx['le']}", file=sys.stderr)
+                elif "ge" in ctx:
+                    print(f"    Hint: Value must be ≥ {ctx['ge']}", file=sys.stderr)
+                elif "lt" in ctx:
+                    print(f"    Hint: Value must be < {ctx['lt']}", file=sys.stderr)
+                elif "gt" in ctx:
+                    print(f"    Hint: Value must be > {ctx['gt']}", file=sys.stderr)
+
+        print("\nRun with --help to see all available options\n", file=sys.stderr)
+        sys.exit(1)
 
     wd: Path = cast(Path, getattr(opts, "working_directory"))
     wd.mkdir(parents=True, exist_ok=True)
@@ -103,17 +146,17 @@ def run_cli(
     # 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(
+                Laminar.start_as_current_span(
                     name=f"{trace_name}-{project_name}", input=[opts.model_dump_json()]
                 )
             )
 
+        if not settings.prefect_api_key and not _running_under_pytest():
+            stack.enter_context(prefect_test_harness())
+            stack.enter_context(disable_run_logger())
+
         asyncio.run(
             run_pipelines(
                 project_name=project_name,

ai_pipeline_core/simple_runner/simple_runner.py

@@ -77,7 +77,9 @@ async def run_pipeline(
 ) -> DocumentList:
     """Execute a single pipeline flow."""
     if flow_name is None:
-        flow_name = getattr(flow_func, "name", getattr(flow_func, "__name__", "flow"))
+        # For Prefect Flow objects, use their name attribute
+        # For regular functions, fall back to __name__
+        flow_name = getattr(flow_func, "name", None) or getattr(flow_func, "__name__", "flow")
 
     logger.info(f"Running Flow: {flow_name}")
 
@@ -126,7 +128,10 @@ async def run_pipelines(
     for i in range(start_index, end_index + 1):
         flow_func = flows[i]
         config = flow_configs[i]
-        flow_name = getattr(flow_func, "name", getattr(flow_func, "__name__", f"flow_{i + 1}"))
+        # For Prefect Flow objects, use their name attribute; for functions, use __name__
+        flow_name = getattr(flow_func, "name", None) or getattr(
+            flow_func, "__name__", f"flow_{i + 1}"
+        )
 
         logger.info(f"--- [Step {i + 1}/{num_steps}] Running Flow: {flow_name} ---")
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-pipeline-core
-Version: 0.1.8
+Version: 0.1.10
 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
@@ -528,29 +528,9 @@ Built with:
 - [LiteLLM](https://litellm.ai/) - LLM proxy
 - [Pydantic](https://pydantic-docs.helpmanual.io/) - Data validation
 
-## What's New in v0.1.8
-
-### 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
-
-### 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
-
-### 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.8
+**Current Version**: 0.1.10
 **Status**: Internal Preview
 **API Stability**: Unstable - Breaking changes expected
 **Recommended Use**: Learning and reference only

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

@@ -1,20 +1,21 @@
-ai_pipeline_core/__init__.py,sha256=dWkrDbW3oqrplHH7oBQ59dOc0wtJr0AcKVtQo63C_wM,1662
+ai_pipeline_core/__init__.py,sha256=qKdAEzvFaIG3FgMh-90X825rcL4vqshSM2xI_WIeiq0,1711
 ai_pipeline_core/exceptions.py,sha256=_vW0Hbw2LGb5tcVvH0YzTKMff7QOPfCRr3w-w_zPyCE,968
 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/prompt_manager.py,sha256=e6i9xOpgmyj-0FoJQg4Y4ZgnYSOUbCARU4UYNk_rT-0,4938
 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=AIdkg2RIyYB5Tje1GmnQqtk8qesOIQwtwzEztypYIhg,13121
+ai_pipeline_core/documents/__init__.py,sha256=a5fdAZxlIX5j-BEcawFnBN3jwyR1nHuvy5iw5G1MwC8,415
+ai_pipeline_core/documents/document.py,sha256=3X1u78If77UqoHgl1uTiwqCc5QdQ9kbGmkL6LFoJVUM,16405
 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/temporary_document.py,sha256=qaJYNza9EyvgBh7uch8Oic6DDk3QL0OEXGF-zuvhK_4,358
 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=gRCtiahTA7h6_xVPY3su85pZbu5gu41yXUgGLILey2E,3220
+ai_pipeline_core/flow/config.py,sha256=j2FP56gTNqNrxrtUnkfn-mUnIs1Cayy2ge4TzoDqj8E,3856
 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
@@ -27,9 +28,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=1X2kkdsGFIewYMxtoRVDS1RY6cx5wNVEIw-TeShbLCc,4281
-ai_pipeline_core/simple_runner/simple_runner.py,sha256=70BHT1iz-G368H2t4tsWAVni0jw2VkWVdnKICuVtLPw,5009
-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,,
+ai_pipeline_core/simple_runner/cli.py,sha256=vRB10SiBFCHD9eqjqSDNZkXYrL3oIQsxNUrHi6L7hu4,6310
+ai_pipeline_core/simple_runner/simple_runner.py,sha256=TVFFVWAt2pxIJdMqVgxXJ1wHn1Xf_-N1fSMVNQH-Hqo,5253
+ai_pipeline_core-0.1.10.dist-info/METADATA,sha256=HGRwvKh5XDGW7ufmmZ3lIwqVnZVr3eb8hLxYFCXhEbc,18010
+ai_pipeline_core-0.1.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ai_pipeline_core-0.1.10.dist-info/licenses/LICENSE,sha256=kKj8mfbdWwkyG3U6n7ztB3bAZlEwShTkAsvaY657i3I,1074
+ai_pipeline_core-0.1.10.dist-info/RECORD,,