Build AI methods with your coding agent, then run them anywhere: as an MCP for chatbots, as a webapp for people, or via API for your software.
Fix PipeLLM bug for generating text. improve builder to output ConceptSpec
Louis Choquele3e07850a1ce
diff --git a/pipelex/cogt/content_generation/content_generator.py b/pipelex/cogt/content_generation/content_generator.pyindex 0280a4ef8..575f3636e 100644--- a/pipelex/cogt/content_generation/content_generator.py+++ b/pipelex/cogt/content_generation/content_generator.py@@ -257,9 +257,7 @@ class ContentGenerator(ContentGeneratorProtocol):prompting_style=prompting_style,template_category=template_category,)- jinja2_text = await jinja2_gen_text(jinja2_assignment=jinja2_assignment)- log.dev(f"{self.__class__.__name__} jinja2: {jinja2_text}")- return jinja2_text+ return await jinja2_gen_text(jinja2_assignment=jinja2_assignment)@overrideasync def make_ocr_extract_pages(diff --git a/pipelex/core/pipes/pipe_run_params.py b/pipelex/core/pipes/pipe_run_params.pyindex 34c0ac93e..741ca076a 100644--- a/pipelex/core/pipes/pipe_run_params.py+++ b/pipelex/core/pipes/pipe_run_params.py@@ -34,7 +34,7 @@ class OutputMultiplicityResolution(BaseModel):resolved_multiplicity: PipeOutputMultiplicity | None = Field(description="The final multiplicity value to use after resolution")- enable_multiple_outputs: bool = Field(description="Whether multiple outputs should be generated")+ is_multiple_outputs_enabled: bool = Field(description="Whether multiple outputs should be generated")specific_output_count: int | None = Field(default=None, description="Exact number of outputs to generate, if specified")@@ -126,19 +126,21 @@ def output_multiplicity_to_apply(log.debug("base_multiplicity is bool")return OutputMultiplicityResolution(resolved_multiplicity=base_multiplicity,- enable_multiple_outputs=base_multiplicity,+ is_multiple_outputs_enabled=base_multiplicity,specific_output_count=None,)elif isinstance(base_multiplicity, int):log.debug("base_multiplicity is int")return OutputMultiplicityResolution(resolved_multiplicity=base_multiplicity,- enable_multiple_outputs=True,+ is_multiple_outputs_enabled=True,specific_output_count=base_multiplicity,)else:log.debug("base_multiplicity is None")- return OutputMultiplicityResolution(resolved_multiplicity=base_multiplicity, enable_multiple_outputs=False, specific_output_count=None)+ return OutputMultiplicityResolution(+ resolved_multiplicity=base_multiplicity, is_multiple_outputs_enabled=False, specific_output_count=None+ )# Case 2: Override is a booleanelif isinstance(override_multiplicity, bool):@@ -149,24 +151,24 @@ def output_multiplicity_to_apply(if isinstance(base_multiplicity, bool):log.debug("base_multiplicity is bool - disregarding base, using True")- return OutputMultiplicityResolution(resolved_multiplicity=True, enable_multiple_outputs=True, specific_output_count=None)+ return OutputMultiplicityResolution(resolved_multiplicity=True, is_multiple_outputs_enabled=True, specific_output_count=None)else:log.debug("base_multiplicity is int or None - preserving base value")return OutputMultiplicityResolution(resolved_multiplicity=base_multiplicity,- enable_multiple_outputs=True,+ is_multiple_outputs_enabled=True,specific_output_count=base_multiplicity if isinstance(base_multiplicity, int) else None,)else:log.debug("override_multiplicity is False - forcing single output")- return OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None)+ return OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None)else:# Case 3: Override is an integerlog.debug("override_multiplicity is int - using override value")return OutputMultiplicityResolution(resolved_multiplicity=override_multiplicity,- enable_multiple_outputs=True,+ is_multiple_outputs_enabled=True,specific_output_count=override_multiplicity,)diff --git a/pipelex/libraries/pipelines/builder/builder.plx b/pipelex/libraries/pipelines/builder/builder.plxindex 290beda6a..a9f2a237c 100644--- a/pipelex/libraries/pipelines/builder/builder.plx+++ b/pipelex/libraries/pipelines/builder/builder.plx@@ -20,10 +20,10 @@ description = "This pipe is going to be the entry point for the builder. It willinputs = { brief = "UserBrief" }output = "Dynamic"steps = [- { pipe = "draft_planning_text", result = "plan_draft" },- { pipe = "draft_to_conceptspecs_text", result = "concept_spec_drafts_text" },+ { pipe = "draft_the_plan", result = "plan_draft" },+ { pipe = "draft_the_concepts", result = "concept_drafts" },+ { pipe = "structure_concepts", result = "concept_specs" },# { pipe = "draft_to_pipesignatures_text", result = "pipe_signatures_text" },- # { pipe = "materialize_concept_spec_drafts", result = "concept_spec_drafts" },# { pipe = "materialize_pipe_signatures", result = "pipe_signatures" },# { pipe = "pipe_builder_domain_information", result = "domain_information" },# { pipe = "build_concept_spec", batch_over = "concept_spec_drafts", batch_as = "concept_spec_draft", result = "concept_specs" },@@ -38,21 +38,16 @@ description = "Turn the brief into a DomainInformation object."inputs = { brief = "UserBrief" }output = "DomainInformation"prompt_template = """-Based on the brief output the "domain" of this pipe, and a definition of what it would represent.--Brief:+Name and define the domain of this process:@brief-For example, if the pipe is about generating a compliance matrix out of a RFP, the domain would be "rfp_compliance_matrix"...-It should be not more than 4 words, in snake_case.-For the definition, i would like to see a short description of what the bundle would represent.+For example, if the brief is about generating and analyzing a compliance matrix out of a RFP,+the domain would be "rfp_compliance" and the definition would be "Generating and analyzing compliance related to RFPs".+The domain name should be not more than 4 words, in snake_case.+For the definition, be concise."""-# ────────────────────────────────────────────────────────────────────────────────-# STAGE 1 — plan (natural language pseudo-code, but explicit about IO + sequencing)-# ────────────────────────────────────────────────────────────────────────────────--[pipe.draft_planning_text]+[pipe.draft_the_plan]type = "PipeLLM"description = "Turn the brief into a pseudo-code plan describing controllers, pipes, their inputs/outputs."inputs = { brief = "UserBrief" }@@ -95,17 +90,14 @@ Keep your style concise, no need to write tags such as "Description:", just writ@brief"""-# ────────────────────────────────────────────────────────────────────────────────-# STAGE 2 — textual specs (still TEXT, not structured objects yet)-# ────────────────────────────────────────────────────────────────────────────────-[pipe.draft_to_conceptspecs_text]+[pipe.draft_the_concepts]type = "PipeLLM"description = "Interpret the draft of a plan to create an AI pipeline, and define the needed concepts."inputs = { plan_draft = "PlanDraft", brief = "UserBrief" }output = "ConceptDrafts"llm = "llm_to_engineer"prompt_template = """-We are working on writing an AI pipeleine to answer this brief:+We are working on writing an AI pipeleine to fulfill this brief:@briefWe have already written a plan for the pipeline. It's built using pipes, each with its own inputs (one or more) and output (single).@@ -140,6 +132,22 @@ DO NOT redefine native concepts such as: Text, Image, PDF, Number, Page. if you@plan_draft"""+[pipe.structure_concepts]+type = "PipeLLM"+description = "Structure the concept definitions."+inputs = { concept_drafts = "ConceptDrafts", brief = "UserBrief" }+output = "concept.ConceptSpec"+multiple_output = true+llm = "llm_to_engineer"+prompt_template = """+Structure the concept drafts.++@concept_drafts+"""++++[pipe.draft_to_pipesignatures_text]type = "PipeLLM"description = "Write the pipe signatures for the plan."@@ -224,30 +232,6 @@ Brief:No more than 10 PipeSignatures"""-# ────────────────────────────────────────────────────────────────────────────────-# STAGE 3 — materialize: TEXT → real objects (ConceptSpec[], PipeSignature[])-# ────────────────────────────────────────────────────────────────────────────────--[pipe.materialize_concept_spec_drafts]-type = "PipeLLM"-description = "Turn ConceptSpecsText into ConceptSpec objects."-inputs = { concept_spec_drafts_text = "Text", brief = "UserBrief" }-output = "concept.ConceptSpecDraft"-multiple_output = true-llm = "llm_to_engineer"-prompt_template = """-Materialize ConceptSpec objects from the ConceptSpecsText.-Do not change the information in the input. Just organize the information--ConceptSpecs:-@concept_spec_drafts_text--Brief:-@brief--LIMIT TO A MAXIMUM OF 5 fields for now-"""-[pipe.materialize_pipe_signatures]type = "PipeLLM"description = "Turn PipeSignaturesText into PipeSignature objects that reference the ConceptSpec objects."diff --git a/pipelex/libraries/pipelines/builder/builder.py b/pipelex/libraries/pipelines/builder/builder.pyindex 4493cf68d..3f934808a 100644--- a/pipelex/libraries/pipelines/builder/builder.py+++ b/pipelex/libraries/pipelines/builder/builder.py@@ -25,8 +25,8 @@ from pipelex.types import StrEnumclass DomainInformation(StructuredContent):- domain: str = Field(description="The domain of the pipeline library.")- definition: str = Field(description="The definition of the pipeline library.")+ domain: str = Field(description="Name of the domain of the knowledge work.")+ definition: str = Field(description="Definition of the domain of the knowledge work.")class PipeBuilderError(Exception):diff --git a/pipelex/libraries/pipelines/builder/concept/concept_spec.py b/pipelex/libraries/pipelines/builder/concept/concept_spec.pyindex 406baaec8..00e3827ec 100644--- a/pipelex/libraries/pipelines/builder/concept/concept_spec.py+++ b/pipelex/libraries/pipelines/builder/concept/concept_spec.py@@ -118,7 +118,7 @@ class ConceptSpecDraft(StructuredContent):the_concept_code: str = Field(description="Concept code. Must be PascalCase.")definition: str = Field(description="Description of the concept, in natural language.")structure: str = Field(- description="A description of a dict with fieldnames as keys, and values being a dict with: definition, type, required, default_value",+ description="Description of a dict with fieldnames as keys, and values being a dict with: definition, type, required, default_value",)refines: str | None = Field(default=None,@@ -128,22 +128,7 @@ class ConceptSpecDraft(StructuredContent):class ConceptSpec(StructuredContent):- """Spec defining a concept that can be used in the Pipelex framework.-- A concept represents a structured data type that can either define its own structure- or refine an existing native concept. Concepts are fundamental building blocks in- Pipelex workflows for data validation and transformation.-- Attributes:- the_concept_code: Concept code. Must be PascalCase.- definition: Natural language description of what the concept represents and its purpose.- structure: The concept's field structure. Can be either:- - A string referring to another concept- - A dictionary where keys are field names (in snake_case) and values are- either strings (concept references) or ConceptStructureBlueprint instances- Cannot be used together with 'refines'.- refines: The native concept this concept extends (Text, Image, PDF, TextAndImages,- Number, Page) in PascalCase format. Cannot be used together with 'structure'.+ """Spec structuring a concept: a conceptual data type that can either define its own structure or refine an existing native concept.Validation Rules:1. Mutual exclusivity: A concept must have either 'structure' or 'refines', but not both.@@ -153,17 +138,25 @@ class ConceptSpec(StructuredContent):4. Concept strings: Format is "domain.ConceptCode" where domain is lowercase andConceptCode is PascalCase.5. Native concepts: When refining, must be one of the valid native concepts.- 6. Structure values: In structure dict, values must be either valid concept strings+ 6. Structure values: In structure attribute, values must be either valid concept stringsor ConceptStructureBlueprint instances.-"""model_config = ConfigDict(extra="forbid")the_concept_code: str = Field(description="Concept code. Must be PascalCase.")- definition: str- structure: str | dict[str, str | ConceptStructureSpec] | None = None- refines: str | None = None+ definition: str = Field(description="Description of the concept, in natural language.")+ structure: str | dict[str, str | ConceptStructureSpec] | None = Field(+ default=None,+ description=("Definition of the concept's structure. Each attribute (snake_case) specifies: definition, type, required, default_value"),+ )+ refines: str | None = Field(+ default=None,+ description=(+ "If applicable: the native concept this concept extends (Text, Image, PDF, TextAndImages, Number, Page) "+ "in PascalCase format. Cannot be used together with 'structure'."+ ),+ )@classmethoddef is_native_concept_code(cls, concept_code: str) -> bool:diff --git a/pipelex/pipe_operators/llm/pipe_llm.py b/pipelex/pipe_operators/llm/pipe_llm.pyindex e7478f5fe..fa2d4c4a5 100644--- a/pipelex/pipe_operators/llm/pipe_llm.py+++ b/pipelex/pipe_operators/llm/pipe_llm.py@@ -255,8 +255,9 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):base_multiplicity=self.output_multiplicity,override_multiplicity=pipe_run_params.output_multiplicity,)+ log.debug(f"multiplicity_resolution: {multiplicity_resolution}")applied_output_multiplicity = multiplicity_resolution.resolved_multiplicity- is_multiple_output = multiplicity_resolution.enable_multiple_outputs+ is_multiple_output = multiplicity_resolution.is_multiple_outputs_enabledfixed_nb_output = multiplicity_resolution.specific_output_count# Collect what LLM settings we have for this particular PipeLLM@@ -299,32 +300,31 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):log.verbose(f"is_with_preliminary_text: {is_with_preliminary_text} for pipe {self.code} because the structuring_method is {self.structuring_method}",)- # Append output structure prompt if needed- output_structure_prompt: str | None = PipeLLM.get_output_structure_prompt(- concept_string=pipe_run_params.dynamic_output_concept_code or output_concept.concept_string,- is_with_preliminary_text=is_with_preliminary_text,- )llm_prompt_run_params = PipeRunParams.copy_by_injecting_multiplicity(pipe_run_params=pipe_run_params,applied_output_multiplicity=applied_output_multiplicity,is_with_preliminary_text=is_with_preliminary_text,)+# TODO: we need a better solution for structuring_method (text then object), meanwhile,# we acknowledge the code here with llm_prompt_1 and llm_prompt_2 is overly complex and should be refactored.- llm_prompt_1 = await self.llm_prompt_spec.make_llm_prompt(- output_concept_string=output_concept.concept_string,- context_provider=working_memory,- output_structure_prompt=output_structure_prompt,- extra_params=llm_prompt_run_params.params,- )the_content: StuffContent- if output_concept.structure_class_name == NativeConceptEnum.TEXT and not is_multiple_output:+ log.debug(f"output_concept.structure_class_name: {output_concept.structure_class_name}")+ log.debug(f"TextContent.__class__.__name__: {TextContent.__class__.__name__}")+ log.debug(f"is_multiple_output: {is_multiple_output}")+ if output_concept.structure_class_name == "TextContent" and not is_multiple_output:log.debug(f"PipeLLM generating a single text output: {self.class_name}_gen_text")+ llm_prompt_1_for_text = await self.llm_prompt_spec.make_llm_prompt(+ output_concept_string=output_concept.concept_string,+ context_provider=working_memory,+ output_structure_prompt=None,+ extra_params=llm_prompt_run_params.params,+ )generated_text: str = await content_generator.make_llm_text(job_metadata=job_metadata,- llm_prompt_for_text=llm_prompt_1,+ llm_prompt_for_text=llm_prompt_1_for_text,llm_setting_main=llm_setting_main,)@@ -335,7 +335,7 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):if is_multiple_output:log.debug(f"PipeLLM generating {fixed_nb_output} output(s)" if fixed_nb_output else "PipeLLM generating a list of output(s)")else:- log.debug("PipeLLM generating a single output")+ log.debug(f"PipeLLM generating a single object output, class name: '{output_concept.structure_class_name}'")# TODO: we need a better solution for structuring_method (text then object), meanwhile,# we acknowledge the code here with llm_prompt_1 and llm_prompt_2 is overly complex and should be refactored.@@ -388,6 +388,16 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):else:llm_prompt_2_factory = None+ output_structure_prompt: str | None = PipeLLM.get_output_structure_prompt(+ concept_string=pipe_run_params.dynamic_output_concept_code or output_concept.concept_string,+ is_with_preliminary_text=is_with_preliminary_text,+ )+ llm_prompt_1_for_object = await self.llm_prompt_spec.make_llm_prompt(+ output_concept_string=output_concept.concept_string,+ context_provider=working_memory,+ output_structure_prompt=output_structure_prompt,+ extra_params=llm_prompt_run_params.params,+ )the_content = await self._llm_gen_object_stuff_content(job_metadata=job_metadata,is_multiple_output=is_multiple_output,@@ -395,7 +405,7 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):output_class_name=output_concept.structure_class_name,llm_setting_main=llm_setting_main,llm_setting_for_object=llm_setting_for_object,- llm_prompt_1=llm_prompt_1,+ llm_prompt_1=llm_prompt_1_for_object,llm_prompt_2_factory=llm_prompt_2_factory,content_generator=content_generator,)@@ -517,17 +527,19 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):)@staticmethod- def get_output_structure_prompt(concept_string: str, is_with_preliminary_text: bool) -> str:+ def get_output_structure_prompt(concept_string: str, is_with_preliminary_text: bool) -> str | None:concept = get_required_concept(concept_string=concept_string)class_name = concept.structure_class_nameoutput_class = get_class_registry().get_class(class_name)+ log.debug(f"get_output_structure_prompt for {concept_string} with {is_with_preliminary_text=}")+ log.debug(f"output_class: {output_class}")if not output_class:- return ""+ return Noneclass_structure = StructurePrinter().get_type_structure(tp=output_class, base_class=StuffContent)if not class_structure:- return ""+ return Noneclass_structure_str = "\n".join(class_structure)# TODO: use proper prompt templating for thisdiff --git a/tests/unit/pipelex/core/pipes/data.py b/tests/unit/pipelex/core/pipes/data.pyindex 145267a20..85e6ce250 100644--- a/tests/unit/pipelex/core/pipes/data.py+++ b/tests/unit/pipelex/core/pipes/data.py@@ -34,128 +34,128 @@ OUTPUT_MULTIPLICITY_TO_APPLY_TEST_CASES: list[(None,None,- OutputMultiplicityResolution(resolved_multiplicity=None, enable_multiple_outputs=False, specific_output_count=None),+ OutputMultiplicityResolution(resolved_multiplicity=None, is_multiple_outputs_enabled=False, specific_output_count=None),"base=None, override=None",),(True,None,- OutputMultiplicityResolution(resolved_multiplicity=True, enable_multiple_outputs=True, specific_output_count=None),+ OutputMultiplicityResolution(resolved_multiplicity=True, is_multiple_outputs_enabled=True, specific_output_count=None),"base=True, override=None",),(False,None,- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),"base=False, override=None",),- (3, None, OutputMultiplicityResolution(resolved_multiplicity=3, enable_multiple_outputs=True, specific_output_count=3), "base=3, override=None"),- (5, None, OutputMultiplicityResolution(resolved_multiplicity=5, enable_multiple_outputs=True, specific_output_count=5), "base=5, override=None"),+ (3, None, OutputMultiplicityResolution(resolved_multiplicity=3, is_multiple_outputs_enabled=True, specific_output_count=3), "base=3, override=None"),+ (5, None, OutputMultiplicityResolution(resolved_multiplicity=5, is_multiple_outputs_enabled=True, specific_output_count=5), "base=5, override=None"),# Override is False - force single output regardless of base(None,False,- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),"base=None, override=False",),(True,False,- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),"base=True, override=False",),(False,False,- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),"base=False, override=False",),(3,False,- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),"base=3, override=False",),(10,False,- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),"base=10, override=False",),# Override is True - enable multiple outputs(None,True,- OutputMultiplicityResolution(resolved_multiplicity=None, enable_multiple_outputs=True, specific_output_count=None),+ OutputMultiplicityResolution(resolved_multiplicity=None, is_multiple_outputs_enabled=True, specific_output_count=None),"base=None, override=True",),(True,True,- OutputMultiplicityResolution(resolved_multiplicity=True, enable_multiple_outputs=True, specific_output_count=None),+ OutputMultiplicityResolution(resolved_multiplicity=True, is_multiple_outputs_enabled=True, specific_output_count=None),"base=True, override=True",),(False,True,- OutputMultiplicityResolution(resolved_multiplicity=True, enable_multiple_outputs=True, specific_output_count=None),+ OutputMultiplicityResolution(resolved_multiplicity=True, is_multiple_outputs_enabled=True, specific_output_count=None),"base=False, override=True",),(3,True,- OutputMultiplicityResolution(resolved_multiplicity=3, enable_multiple_outputs=True, specific_output_count=3),+ OutputMultiplicityResolution(resolved_multiplicity=3, is_multiple_outputs_enabled=True, specific_output_count=3),"base=3, override=True - preserve base count",),(7,True,- OutputMultiplicityResolution(resolved_multiplicity=7, enable_multiple_outputs=True, specific_output_count=7),+ OutputMultiplicityResolution(resolved_multiplicity=7, is_multiple_outputs_enabled=True, specific_output_count=7),"base=7, override=True - preserve base count",),# Override is int - use override count, enable multiple outputs- (None, 2, OutputMultiplicityResolution(resolved_multiplicity=2, enable_multiple_outputs=True, specific_output_count=2), "base=None, override=2"),- (True, 4, OutputMultiplicityResolution(resolved_multiplicity=4, enable_multiple_outputs=True, specific_output_count=4), "base=True, override=4"),+ (None, 2, OutputMultiplicityResolution(resolved_multiplicity=2, is_multiple_outputs_enabled=True, specific_output_count=2), "base=None, override=2"),+ (True, 4, OutputMultiplicityResolution(resolved_multiplicity=4, is_multiple_outputs_enabled=True, specific_output_count=4), "base=True, override=4"),(False,6,- OutputMultiplicityResolution(resolved_multiplicity=6, enable_multiple_outputs=True, specific_output_count=6),+ OutputMultiplicityResolution(resolved_multiplicity=6, is_multiple_outputs_enabled=True, specific_output_count=6),"base=False, override=6",),(3,8,- OutputMultiplicityResolution(resolved_multiplicity=8, enable_multiple_outputs=True, specific_output_count=8),+ OutputMultiplicityResolution(resolved_multiplicity=8, is_multiple_outputs_enabled=True, specific_output_count=8),"base=3, override=8 - override takes precedence",),(5,1,- OutputMultiplicityResolution(resolved_multiplicity=1, enable_multiple_outputs=True, specific_output_count=1),+ OutputMultiplicityResolution(resolved_multiplicity=1, is_multiple_outputs_enabled=True, specific_output_count=1),"base=5, override=1 - override takes precedence",),# Edge cases with negative numbers(-1,None,- OutputMultiplicityResolution(resolved_multiplicity=-1, enable_multiple_outputs=True, specific_output_count=-1),+ OutputMultiplicityResolution(resolved_multiplicity=-1, is_multiple_outputs_enabled=True, specific_output_count=-1),"base=-1, override=None",),- (3, -2, OutputMultiplicityResolution(resolved_multiplicity=-2, enable_multiple_outputs=True, specific_output_count=-2), "base=3, override=-2"),+ (3, -2, OutputMultiplicityResolution(resolved_multiplicity=-2, is_multiple_outputs_enabled=True, specific_output_count=-2), "base=3, override=-2"),# Edge cases with zero- (0, None, OutputMultiplicityResolution(resolved_multiplicity=0, enable_multiple_outputs=True, specific_output_count=0), "base=0, override=None"),- (True, 0, OutputMultiplicityResolution(resolved_multiplicity=0, enable_multiple_outputs=True, specific_output_count=0), "base=True, override=0"),+ (0, None, OutputMultiplicityResolution(resolved_multiplicity=0, is_multiple_outputs_enabled=True, specific_output_count=0), "base=0, override=None"),+ (True, 0, OutputMultiplicityResolution(resolved_multiplicity=0, is_multiple_outputs_enabled=True, specific_output_count=0), "base=True, override=0"),# Large numbers(1000,None,- OutputMultiplicityResolution(resolved_multiplicity=1000, enable_multiple_outputs=True, specific_output_count=1000),+ OutputMultiplicityResolution(resolved_multiplicity=1000, is_multiple_outputs_enabled=True, specific_output_count=1000),"base=1000, override=None",),(100,999,- OutputMultiplicityResolution(resolved_multiplicity=999, enable_multiple_outputs=True, specific_output_count=999),+ OutputMultiplicityResolution(resolved_multiplicity=999, is_multiple_outputs_enabled=True, specific_output_count=999),"base=100, override=999",),]diff --git a/tests/unit/pipelex/core/pipes/test_pipe_run_params.py b/tests/unit/pipelex/core/pipes/test_pipe_run_params.pyindex 3e96e7027..906366bbb 100644--- a/tests/unit/pipelex/core/pipes/test_pipe_run_params.py+++ b/tests/unit/pipelex/core/pipes/test_pipe_run_params.py@@ -120,7 +120,7 @@ class TestOutputMultiplicityToApply:"""Test output_multiplicity_to_apply with all parameter combinations."""result = output_multiplicity_to_apply(base, override)assert result.resolved_multiplicity == expected_result.resolved_multiplicity, f"Failed resolved_multiplicity for case: {description}"- assert result.enable_multiple_outputs == expected_result.enable_multiple_outputs, f"Failed enable_multiple_outputs for case: {description}"+ assert result.is_multiple_outputs_enabled == expected_result.is_multiple_outputs_enabled, f"Failed enable_multiple_outputs for case: {description}"assert result.specific_output_count == expected_result.specific_output_count, f"Failed specific_output_count for case: {description}"def test_override_none_uses_base(self):@@ -128,25 +128,25 @@ class TestOutputMultiplicityToApply:# Base None -> single outputresult = output_multiplicity_to_apply(None, None)assert result.resolved_multiplicity is None- assert result.enable_multiple_outputs is False+ assert result.is_multiple_outputs_enabled is Falseassert result.specific_output_count is None# Base True -> multiple output, LLM decidesresult = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=None)assert result.resolved_multiplicity is True- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count is None# Base int -> multiple output with specific countresult = output_multiplicity_to_apply(base_multiplicity=3, override_multiplicity=None)assert result.resolved_multiplicity == 3- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == 3# Base False -> single outputresult = output_multiplicity_to_apply(base_multiplicity=False, override_multiplicity=None)assert result.resolved_multiplicity is False- assert result.enable_multiple_outputs is False+ assert result.is_multiple_outputs_enabled is Falseassert result.specific_output_count is Nonedef test_override_false_forces_single_output(self):@@ -157,7 +157,7 @@ class TestOutputMultiplicityToApply:for base in test_bases:result = output_multiplicity_to_apply(base_multiplicity=base, override_multiplicity=False)assert result.resolved_multiplicity is False, f"Failed for base={base}: resolved_multiplicity should be False"- assert result.enable_multiple_outputs is False, f"Failed for base={base}: enable_multiple_outputs should be False"+ assert result.is_multiple_outputs_enabled is False, f"Failed for base={base}: enable_multiple_outputs should be False"assert result.specific_output_count is None, f"Failed for base={base}: specific_output_count should be None"def test_override_true_enables_multiple_outputs(self):@@ -165,26 +165,26 @@ class TestOutputMultiplicityToApply:# Base None -> preserve None but enable multipleresult = output_multiplicity_to_apply(base_multiplicity=None, override_multiplicity=True)assert result.resolved_multiplicity is None- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count is None# Base False -> enable multiple, LLM decides countresult = output_multiplicity_to_apply(base_multiplicity=False, override_multiplicity=True)assert result.resolved_multiplicity is True- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count is None# Base True -> keep Trueresult = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=True)assert result.resolved_multiplicity is True- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count is None# Base int -> preserve count, enable multiplefor base_int in [1, 3, 5, 10]:result = output_multiplicity_to_apply(base_multiplicity=base_int, override_multiplicity=True)assert result.resolved_multiplicity == base_int- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == base_intdef test_override_int_uses_override_count(self):@@ -195,7 +195,7 @@ class TestOutputMultiplicityToApply:for base in test_bases:result = output_multiplicity_to_apply(base_multiplicity=base, override_multiplicity=override_int)assert result.resolved_multiplicity == override_int, f"Failed for base={base}: resolved_multiplicity should be {override_int}"- assert result.enable_multiple_outputs is True, f"Failed for base={base}: enable_multiple_outputs should be True"+ assert result.is_multiple_outputs_enabled is True, f"Failed for base={base}: enable_multiple_outputs should be True"assert result.specific_output_count == override_int, f"Failed for base={base}: specific_output_count should be {override_int}"def test_return_basemodel_structure(self):@@ -205,7 +205,7 @@ class TestOutputMultiplicityToApply:# Test field typesassert result.resolved_multiplicity is None or isinstance(result.resolved_multiplicity, (bool, int))- assert isinstance(result.enable_multiple_outputs, bool)+ assert isinstance(result.is_multiple_outputs_enabled, bool)assert result.specific_output_count is None or isinstance(result.specific_output_count, int)def test_edge_cases(self):@@ -213,29 +213,29 @@ class TestOutputMultiplicityToApply:# Negative numbersresult = output_multiplicity_to_apply(base_multiplicity=-1, override_multiplicity=None)assert result.resolved_multiplicity == -1- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == -1result = output_multiplicity_to_apply(base_multiplicity=3, override_multiplicity=-2)assert result.resolved_multiplicity == -2- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == -2# Zero valuesresult = output_multiplicity_to_apply(base_multiplicity=0, override_multiplicity=None)assert result.resolved_multiplicity == 0- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == 0result = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=0)assert result.resolved_multiplicity == 0- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == 0# Large numbersresult = output_multiplicity_to_apply(base_multiplicity=1000, override_multiplicity=None)assert result.resolved_multiplicity == 1000- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == 1000def test_override_precedence_logic(self):@@ -243,40 +243,40 @@ class TestOutputMultiplicityToApply:# Override False beats any baseresult = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=False)assert result.resolved_multiplicity is False- assert result.enable_multiple_outputs is False+ assert result.is_multiple_outputs_enabled is Falseassert result.specific_output_count is Noneresult = output_multiplicity_to_apply(base_multiplicity=5, override_multiplicity=False)assert result.resolved_multiplicity is False- assert result.enable_multiple_outputs is False+ assert result.is_multiple_outputs_enabled is Falseassert result.specific_output_count is None# Override int beats any baseresult = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=3)assert result.resolved_multiplicity == 3- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == 3result = output_multiplicity_to_apply(base_multiplicity=7, override_multiplicity=3)assert result.resolved_multiplicity == 3- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == 3# Override True with int base preserves intresult = output_multiplicity_to_apply(base_multiplicity=5, override_multiplicity=True)assert result.resolved_multiplicity == 5- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == 5# Override True with bool base becomes Trueresult = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=True)assert result.resolved_multiplicity is True- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count is Noneresult = output_multiplicity_to_apply(base_multiplicity=False, override_multiplicity=True)assert result.resolved_multiplicity is True- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count is Nonedef test_complex_scenarios(self):@@ -284,23 +284,23 @@ class TestOutputMultiplicityToApply:# Scenario: Pipe has base multiplicity=3, runtime wants to disable itresult = output_multiplicity_to_apply(base_multiplicity=3, override_multiplicity=False)assert result.resolved_multiplicity is False- assert result.enable_multiple_outputs is False+ assert result.is_multiple_outputs_enabled is Falseassert result.specific_output_count is None# Scenario: Pipe has no base multiplicity, runtime wants 5 outputsresult = output_multiplicity_to_apply(base_multiplicity=None, override_multiplicity=5)assert result.resolved_multiplicity == 5- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == 5# Scenario: Pipe has base True, runtime wants specific countresult = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=2)assert result.resolved_multiplicity == 2- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == 2# Scenario: Pipe has base count, runtime wants to enable but let LLM decideresult = output_multiplicity_to_apply(base_multiplicity=4, override_multiplicity=True)assert result.resolved_multiplicity == 4 # Preserves base count- assert result.enable_multiple_outputs is True+ assert result.is_multiple_outputs_enabled is Trueassert result.specific_output_count == 4