bioguider 0.2.14__py3-none-any.whl → 0.2.16__py3-none-any.whl

bioguider/agents/evaluation_submission_requirements_task.py

@@ -1,13 +1,18 @@
 
-from typing import Optional
-from pydantic import BaseModel, Field
+
 from bioguider.agents.agent_utils import try_parse_json_object, try_parse_with_llm
 from bioguider.agents.evaluation_task import EvaluationTask
 from bioguider.agents.collection_task import CollectionTask
 from bioguider.agents.identification_task import IdentificationTask
 from bioguider.agents.prompt_utils import CollectionGoalItemEnum
-from bioguider.agents.evaluation_installation_task import StructuredEvaluationInstallationResult
-from bioguider.utils.constants import DEFAULT_TOKEN_USAGE
+from bioguider.utils.constants import (
+    DEFAULT_TOKEN_USAGE, 
+    EvaluationInstallationResult, 
+    EvaluationREADMEResult,
+    SoftwarePackageContentResult,
+    DemoInstructionsResult,
+    EvaluationSubmissionRequirementsResult,
+)
 
 DEMO_INSTRUCTION_GOAL = """
 1. Identify if it provides the instructions to run on provided data
@@ -18,11 +23,6 @@ DEMO_INSTRUCTION_GOAL = """
 DEMO_INSTRUCTION_FINAL_ANSWER = \
 '{{"run_on_data_instruction": <True or False>, "run_on_custom_instruction": <True or False>, "expected_output_description": <True Or False>}}'
 
-class DemoInstructionsResult(BaseModel):
-    run_on_data_instruction: Optional[bool] = Field(description="A boolean value. Does it provide instructions on how to run on provided data?")
-    run_on_custom_instruction: Optional[bool] = Field(description="A boolean value. Does it provide instructions on how to run on custom data?")
-    expected_output_description: Optional[bool] = Field(description="A boolean value. Does it provide the description of expected output?")
-
 class EvaluationSubmissionRequirementsTask(EvaluationTask):
     def __init__(
         self, 
@@ -32,8 +32,8 @@ class EvaluationSubmissionRequirementsTask(EvaluationTask):
         meta_data = None, 
         step_callback = None, 
         summarized_files_db = None,
-        readme_files_evaluation: dict | None = None,
-        installation_evaluation: dict | None = None,
+        readme_files_evaluation: dict[str, EvaluationREADMEResult] | None = None,
+        installation_evaluation: EvaluationInstallationResult | None = None,
         installation_files: list[str] | None = None
     ):
         super().__init__(llm, repo_path, gitignore_path, meta_data, step_callback, summarized_files_db)
@@ -59,24 +59,24 @@ class EvaluationSubmissionRequirementsTask(EvaluationTask):
 
         return files
     
-    def _evaluate_software_package_content(self):
+    def _evaluate_software_package_content(self) -> tuple[SoftwarePackageContentResult, list[str]]:
         files = self._collect_software_package_content()
         if len(files) == 3:
-            return {
-                "compiled_standalone_software": files[0].strip().lower() != "n/a",
-                "source_code": files[1].strip().lower() != "n/a",
-                "demo_dataset": files[2].strip().lower() != "n/a",
-            }, files
+            return SoftwarePackageContentResult(
+                compiled_standalone_software=files[0].strip().lower() != "n/a",
+                source_code=files[1].strip().lower() != "n/a",
+                demo_dataset=files[2].strip().lower() != "n/a",
+            ), files
         else:
-            return {
-                "compiled_standalone_software": False,
-                "source_code": False,
-                "demo_dataset": False,
-            }, files
+            return SoftwarePackageContentResult(
+                compiled_standalone_software=False,
+                source_code=False,
+                demo_dataset=False,
+            ), files
     
-    def _evaluatie_demo_instructions(self):
+    def _evaluatie_demo_instructions(self) -> tuple[DemoInstructionsResult | None, list[str]]:
         readme_files = [f for f in self.readme_files_evaluation.keys() \
-                        if self.readme_files_evaluation[f]["evaluation"]["project_level"]]
+                        if self.readme_files_evaluation[f].project_level]
         installation_files = self.installation_files if self.installation_files is not None else []
         provided_files = readme_files + installation_files
         provided_files = provided_files if len(provided_files) > 0 else None
@@ -99,43 +99,58 @@ class EvaluationSubmissionRequirementsTask(EvaluationTask):
         parsed_obj = self._parse_demo_instruction_result(final_answer)
         return parsed_obj, provided_files
 
-    def _parse_demo_instruction_result(self, result: str | dict):
+    def _parse_demo_instruction_result(self, result: str | dict) -> DemoInstructionsResult:
+        parsed_obj = None
         if isinstance(result, dict):
-            return result
-        obj = try_parse_json_object(result)
-        if obj is None:
-            obj, token_usage = try_parse_with_llm(
-                llm=self.llm,
-                input_text=result,
-                schema=DemoInstructionsResult,
-            )
-            obj = vars(obj) if obj is not None else obj
-            self.print_step(token_usage=token_usage)
-            self.print_step(step_output=str(obj))
-
-        return obj
-
+            parsed_obj = result
+        else:
+            parsed_obj = try_parse_json_object(result)
+            if parsed_obj is None:
+                parsed_obj, token_usage = try_parse_with_llm(
+                    llm=self.llm,
+                    input_text=result,
+                    schema=DemoInstructionsResult,
+                )
+                parsed_obj = vars(parsed_obj) if parsed_obj is not None else parsed_obj
+                self.print_step(token_usage=token_usage)
+                self.print_step(step_output=str(parsed_obj))
+
+        return DemoInstructionsResult(
+            run_on_data_instruction = parsed_obj["run_on_data_instruction"] \
+                if "run_on_data_instruction" in parsed_obj else False,
+            run_on_custom_instruction = parsed_obj["run_on_custom_instruction"] \
+                if "run_on_custom_instruction" in parsed_obj else False,
+            expected_output_description = parsed_obj["expected_output_description"] \
+                if "expected_output_description" in parsed_obj else False,
+        )
 
     def _combine_evaluation(
         self,
-        software_evaluation: dict,
-        demo_evaluation: dict,
-    ):
+        software_evaluation: SoftwarePackageContentResult,
+        demo_evaluation: DemoInstructionsResult,
+    ) -> EvaluationSubmissionRequirementsResult:
         readme_files = [f for f in self.readme_files_evaluation.keys() \
-                        if self.readme_files_evaluation[f]["evaluation"]["project_level"]]
-        structured_install_evaluation: StructuredEvaluationInstallationResult = \
-            self.installation_evaluation["structured_evaluation"]
+                        if self.readme_files_evaluation[f].project_level]
+        structured_install_evaluation = self.installation_evaluation.structured_evaluation
         software_dependency = structured_install_evaluation.dependency_number > 0
         install_tutorial = structured_install_evaluation.install_tutorial
-        license = any([self.readme_files_evaluation[f]["structured_evaluation"].license_score for f in readme_files])
-        return {
-            **software_evaluation,
-            **demo_evaluation,
-            "complete_readme": len(readme_files) > 0,
-            "software_dependency": software_dependency,
-            "install_tutorial": install_tutorial,
-            "license": license,
-        }
+        license = any([
+            self.readme_files_evaluation[f].structured_evaluation.license_score \
+                if self.readme_files_evaluation[f].structured_evaluation is not None \
+                else False for f in readme_files
+        ])
+        return EvaluationSubmissionRequirementsResult(
+            compiled_standalone_software=software_evaluation.compiled_standalone_software,
+            source_code=software_evaluation.source_code,
+            demo_dataset=software_evaluation.demo_dataset,
+            run_on_data_instruction=demo_evaluation.run_on_data_instruction,
+            run_on_custom_instruction=demo_evaluation.run_on_custom_instruction,
+            expected_output_description=demo_evaluation.expected_output_description,
+            complete_readme=len(readme_files) > 0,
+            software_dependency=software_dependency,
+            install_tutorial=install_tutorial,
+            license=license,
+        )
 
     def _evaluate(self, files):
         

bioguider/agents/evaluation_task.py

@@ -11,7 +11,7 @@ from bioguider.agents.agent_utils import read_file
 from bioguider.agents.prompt_utils import EVALUATION_INSTRUCTION
 from bioguider.database.summarized_file_db import SummarizedFilesDb
 from bioguider.utils.constants import DEFAULT_TOKEN_USAGE, ProjectMetadata
-from .common_agent import CommonConversation
+from .common_conversation import CommonConversation
 from ..utils.pyphen_utils import PyphenReadability
 
 logger = logging.getLogger(__name__)

bioguider/agents/identification_observe_step.py

@@ -5,6 +5,7 @@ from bioguider.agents.agent_utils import ObservationResult
 from bioguider.agents.common_agent_2step import CommonAgentTwoSteps, CommonAgentTwoChainSteps
 from bioguider.agents.identification_task_utils import IdentificationWorkflowState
 from bioguider.agents.peo_common_step import PEOWorkflowState, PEOCommonStep
+from bioguider.utils.constants import MAX_STEP_COUNT
 
 
 ## observation system prompt
@@ -76,11 +77,14 @@ class IdentificationObserveStep(PEOCommonStep):
         )
 
     def _execute_directly(self, state: IdentificationWorkflowState):
+        step_count = state["step_count"]
+        instruction = "Now, we have reached max recursion limit, please give me the **final answer** based on the current information" \
+            if step_count == MAX_STEP_COUNT/3 - 2 else "Now, Let's begin."
         system_prompt = self._prepare_system_prompt(state)
         agent = CommonAgentTwoSteps(llm=self.llm)
         res, _, token_usage, reasoning_process = agent.go(
             system_prompt=system_prompt,
-            instruction_prompt="Now, let's begin.",
+            instruction_prompt=instruction,
             schema=ObservationResult,
         )
         state["final_answer"] = res.FinalAnswer
@@ -88,9 +92,10 @@ class IdentificationObserveStep(PEOCommonStep):
         thoughts = res.Thoughts
         state["step_analysis"] = analysis
         state["step_thoughts"] = thoughts
+        state["step_count"] += 1
         self._print_step(
             state,
-            step_output=f"**Observation Reasoning Process**\n{reasoning_process}"
+            step_output=f"**Observation Reasoning Process {state['step_count']}**\n{reasoning_process}"
         )
         self._print_step(
             state,

bioguider/agents/identification_task.py

@@ -173,6 +173,7 @@ class IdentificationTask(AgentTask):
         s = self._go_graph({
             "goal": IDENTIFICATION_GOAL_PROJECT_TYPE,
             "final_answer_example": PROJECT_TYPE_FINAL_ANSWER_EXAMPLE,
+            "step_count": 0,
         })
         proj_type = s["final_answer"] if "final_answer" in s else "unknown type"
         return self._parse_project_type(proj_type)
@@ -181,6 +182,7 @@ class IdentificationTask(AgentTask):
         s = self._go_graph({
             "goal": IDENTIFICATION_GOAL_PRIMARY_LANGUAGE,
             "final_answer_example": PRIMARY_LANGUAGE_FINAL_ANSWER_EXAMPLE,
+            "step_count": 0,
         })
         language = s["final_answer"] if "final_answer" in s else "unknown type"
         return self._parse_primary_language(language)
@@ -189,6 +191,7 @@ class IdentificationTask(AgentTask):
         s = self._go_graph({
             "goal": IDENTIFICATION_GOAL_META_DATA,
             "final_answer_example": META_DATA_FINAL_ANSWER_EXAMPLE,
+            "step_count": 0,
         })
         meta_data = s["final_answer"] if "final_answer" in s else "unknown type"
         return self._parse_meta_data(meta_data)
@@ -205,6 +208,7 @@ class IdentificationTask(AgentTask):
             "final_answer_example": final_answer_example,
             "plan_instructions": plan_instructions,
             "observe_instructions": observe_instructions,
+            "step_count": 0,
         })
         return s["final_answer"] if "final_answer" in s else None
 

bioguider/agents/identification_task_utils.py

@@ -18,3 +18,5 @@ class IdentificationWorkflowState(TypedDict):
     step_output: Optional[str]
     step_analysis: Optional[str]
     step_thoughts: Optional[str]
+
+    step_count: Optional[int]

bioguider/agents/prompt_utils.py

@@ -208,9 +208,12 @@ If **any one** of these is present, the document should be classified as Contrib
 """,
         "plan_important_instructions": """ - A comiled standalone software file is non-textual and appears to be in an executable format (e.g., `.exe`, `.dll`, `.so`, `.bin`, `.elf`).
  - A comiled standalone software file **is not a script or compiled library**, that is, It is not a wrapper script (e.g., shell, Python, Python notebook or Rmd) nor a dynamic/shared library meant for linking.
- - When identifying source code file, prioritize analyzing the file's **extension** and **file name** and try to avoid reading file, using check_file_related_tool or summarizing file content.
- - When identifying example data, prioritize analyzing the file's **extension** (like .dat, .csv, .fastq, and so on) and **file name** (like example_data.txt, example.dat, and so on). If extension/name is ambiguous, use summarizing file content to decide.
+   So, when you are identifying a binary file, **do not** use any tools (our tools don't work for binary file), you need to figure out if it is compiled standalone software file by the file name and extension on your own.
+ - **Source code files** are determined by their **extensions** or **file names** (e.g., `.py`, `.R`, `.ipynb`, `.ts`, `.js`). **Do not open or summarize their content.**
+ - **Example data files** are identified by typical data extensions (e.g., `.dat`, `.csv`, `.fastq`) or names like `example_*.txt`. 
+   If extension/name is ambiguous, use summarize_file_tool to summarize file content to decide, **do not** read the file content.
  - **Note**: You **only need to detect** whether at least **one** compiled standalone software file, **one** source code file and **one** example data file exist — no need to list all such files.
+ - **Note**: When identifying **compiled standalone software** or **example data files**, **ignore** any **image files** (e.g., `.png`, `.jpg`, `.jpeg`, `.gif`, `.svg`) and **image folders** (directories containing primarily images).
 """,
         "observe_important_instructions": """ - A comiled standalone software file is non-textual and appears to be in an executable format (e.g., `.exe`, `.dll`, `.so`, `.bin`, `.elf`).
  - A comiled standalone software file **is not a script or compiled library**, that is, It is not a wrapper script (e.g., shell, Python, Python notebook or Rmd) nor a dynamic/shared library meant for linking.

bioguider/utils/constants.py

@@ -2,6 +2,8 @@
 from enum import Enum
 from typing import Optional
 
+from pydantic import BaseModel, Field
+
 DEFAULT_TOKEN_USAGE = {
     "total_tokens": 0,
     "completion_tokens": 0,
@@ -39,4 +41,88 @@ class ProjectMetadata:
         self.license = license
 
 MAX_FILE_LENGTH=10 *1024 # 10K
-MAX_SENTENCE_NUM=20
+MAX_SENTENCE_NUM=20
+MAX_STEP_COUNT=3*10
+
+class ProjectLevelEvaluationREADMEResult(BaseModel):
+    project_level: Optional[bool]=Field(description="A boolean value specifying if the README file is **project-level** README. TRUE: project-level, FALSE, folder-level")
+
+class StructuredEvaluationREADMEResult(BaseModel):
+    available_score: Optional[bool]=Field(description="A boolean value, Is the README accessible and present?")
+    readability_score: Optional[str]=Field(description="A string value, could be `Poor`, `Fair`, `Good`, or `Excellent`")
+    readability_suggestions: Optional[str]=Field(description="Suggestions to improve readability if necessary")
+    project_purpose_score: Optional[bool]=Field(description="A boolean value. Is the project's goal or function clearly stated?")
+    project_purpose_suggestions: Optional[str]=Field(description="Suggestions if not clear")
+    hardware_and_software_spec_score: Optional[str]=Field(description="A string value, could be `Poor`, `Fair`, `Good`, or `Excellent`")
+    hardware_and_software_spec_suggestions: Optional[str]=Field(description="Suggestions if not clear")
+    dependency_score: Optional[str]=Field(description="A string value, could be `Poor`, `Fair`, `Good`, or `Excellent`")
+    dependency_suggestions: Optional[str]=Field(description="Suggestions if dependencies are not clearly stated")
+    license_score: Optional[bool]=Field(description="A boolean value, Are contributor or maintainer details provided?")
+    license_suggestions: Optional[str]=Field(description="Suggestions to improve license information")
+    contributor_author_score: Optional[bool]=Field(description="A boolean value. are contributors or author included?")
+    overall_score: str=Field(description="A overall scroll for the README quality, could be `Poor`, `Fair`, `Good`, or `Excellent`")
+
+class FreeProjectLevelEvaluationREADMEResult(BaseModel):
+    available: Optional[str]=Field(description="A string including assessment and suggestion for the availability of the README file")
+    readability: Optional[str]=Field(description="A string including assessment and suggestion for the readability of the README file")
+    project_purpose: Optional[str]=Field(description="A string including assessment and suggestion for the project purpose of the README file")
+    hardware_and_software_spec: Optional[str]=Field(description="A string including assessment and suggestion for the hardware and software spec and compatibility description of the README file")
+    dependency: Optional[str]=Field(description="A string including assessment and suggestion for the dependencies of the README file")
+    license: Optional[str]=Field(description="A string including assessment and suggestion for the license information of the README file")
+    contributor_author: Optional[str]=Field(description="A string including assessment and suggestion for the contributor and author information of the README file")
+
+class FreeFolderLevelEvaluationREADMEResult(BaseModel):
+    score: Optional[str]=Field(description="An overall score")
+    key_strengths: Optional[str]=Field(description="A string specifying the key strengths of README file.")
+    overall_improvement_suggestions: Optional[list[str]]=Field(description="A list of overall improvement suggestions")
+
+class EvaluationREADMEResult(BaseModel):
+    project_level: bool
+    structured_evaluation: StructuredEvaluationREADMEResult | None
+    free_evaluation: FreeProjectLevelEvaluationREADMEResult | FreeFolderLevelEvaluationREADMEResult | None
+    structured_reasoning_process: str | None
+    free_reasoning_process: str | None
+
+
+class StructuredEvaluationInstallationResult(BaseModel):
+    install_available: Optional[bool]=Field(description="A boolean value. Is the installation documents accessible and present?")
+    install_tutorial: Optional[bool]=Field(description="A boolean value. Is the installation tutorial provided?")
+    dependency_number: Optional[int]=Field(description="A number. It is the number of dependencies that are required to install.")
+    dependency_suggestions: Optional[str]=Field(description="A string value. It is the specific improvements if necessary, such as missing dependencies")
+    compatible_os: Optional[bool]=Field(description="A boolean value. Is compatible operating system described?")
+    overall_score: Optional[str]=Field(description="A overall scroll for the installation quality, could be `Poor`, `Fair`, `Good`, or `Excellent`")
+
+class FreeEvaluationInstallationResult(BaseModel):
+    ease_of_access: Optional[str]=Field(description="A string including assessment and suggestions for the ease of access of the installation information")
+    clarity_of_dependency: Optional[str]=Field(description="A string including assessment and suggestions for the clarity of dependency specification")
+    hardware_requirements: Optional[str]=Field(description="A string including assessment and suggestions for the hardware requirements")
+    installation_guide: Optional[str]=Field(description="A string including assessment and suggestions for the installation guide")
+    compatible_os: Optional[str]=Field(description="A string including assessment and suggestions for the compatible operating system")
+
+class EvaluationInstallationResult(BaseModel):
+    structured_evaluation: StructuredEvaluationInstallationResult | None
+    free_evaluation: FreeEvaluationInstallationResult | None
+    structured_reasoning_process: str | None
+    free_reasoning_process: str | None
+
+class SoftwarePackageContentResult(BaseModel):
+    compiled_standalone_software: Optional[bool] = Field(description="A boolean value. Does it provide the compiled standalone software?")
+    source_code: Optional[bool] = Field(description="A boolean value. Does it provide the source code?")
+    demo_dataset: Optional[bool] = Field(description="A boolean value. Does it provide the demo dataset?")
+
+class DemoInstructionsResult(BaseModel):
+    run_on_data_instruction: Optional[bool] = Field(description="A boolean value. Does it provide instructions on how to run on provided data?")
+    run_on_custom_instruction: Optional[bool] = Field(description="A boolean value. Does it provide instructions on how to run on custom data?")
+    expected_output_description: Optional[bool] = Field(description="A boolean value. Does it provide the description of expected output?")
+
+class EvaluationSubmissionRequirementsResult(BaseModel):
+    compiled_standalone_software: bool
+    source_code: bool
+    demo_dataset: bool
+    run_on_data_instruction: bool
+    run_on_custom_instruction: bool
+    expected_output_description: bool
+    complete_readme: bool
+    software_dependency: bool
+    install_tutorial: bool
+    license: bool

bioguider/utils/utils.py

@@ -1,5 +1,10 @@
 import logging
+import re
+import subprocess
+from typing import Optional
 import tiktoken
+
+from bioguider.utils.constants import DEFAULT_TOKEN_USAGE
 logger = logging.getLogger(__name__)
 
 def count_tokens(text: str, local_ollama: bool = False) -> int:
@@ -24,4 +29,43 @@ def count_tokens(text: str, local_ollama: bool = False) -> int:
         # Fallback to a simple approximation if tiktoken fails
         logger.warning(f"Error counting tokens with tiktoken: {e}")
         # Rough approximation: 4 characters per token
-        return len(text) // 4
+        return len(text) // 4
+
+
+def run_command(command: list, cwd: str = None, timeout: int = None):
+    """
+    Run a shell command with optional timeout and return stdout, stderr, and return code.
+    """
+    try:
+        result = subprocess.run(
+            command,
+            cwd=cwd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            timeout=timeout
+        )
+        return result.stdout, result.stderr, result.returncode
+    except subprocess.TimeoutExpired as e:
+        return e.stdout or "", e.stderr or f"Command timed out after {timeout} seconds", -1
+
+def escape_braces(text: str) -> str:
+    # First replace single } not part of }} with }}
+    text = re.sub(r'(?<!})}(?!})', '}}', text)
+    # Then replace single { not part of {{
+    text = re.sub(r'(?<!{){(?!{)', '{{', text)
+    return text
+
+def increase_token_usage(
+    token_usage: Optional[dict] = None,
+    incremental: dict = {**DEFAULT_TOKEN_USAGE},
+):
+    if token_usage is None:
+        token_usage = {**DEFAULT_TOKEN_USAGE}
+    token_usage["total_tokens"] += incremental["total_tokens"]
+    token_usage["completion_tokens"] += incremental["completion_tokens"]
+    token_usage["prompt_tokens"] += incremental["prompt_tokens"]
+
+    return token_usage
+
+    

{bioguider-0.2.14.dist-info → bioguider-0.2.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bioguider
-Version: 0.2.14
+Version: 0.2.16
 Summary: An AI-Powered package to help biomedical developers to generate clear documentation
 License: MIT
 Author: Cankun Wang

{bioguider-0.2.14.dist-info → bioguider-0.2.16.dist-info}/RECORD

@@ -1,32 +1,33 @@
 bioguider/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bioguider/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bioguider/agents/agent_task.py,sha256=B_QGkoA96GdrYSX29TQ_tct_y8z4zS4l5Cn0-eph88k,2863
+bioguider/agents/agent_task.py,sha256=TL0Zx8zOmiAVslmNbfMPQ38qTQ73QospY6Dwrwf8POg,2890
 bioguider/agents/agent_tools.py,sha256=r21wHV6a-Ic2T0dk4YzA-_d7PodHPM3GzRxJqv-llSw,7286
-bioguider/agents/agent_utils.py,sha256=FFFhZvL_THvZ2Y7QwFmi3jsUd1i7PYi9tPJNMTVUsgY,14702
+bioguider/agents/agent_utils.py,sha256=Om1xwAmRdHFC4jkbtaBM3p309z5KFjMX1a6BFVPXX68,14449
 bioguider/agents/collection_execute_step.py,sha256=Ev4BLjjmBdsc52M1zrq7QK8g7fsffDkSxu-jN2rvedw,5614
-bioguider/agents/collection_observe_step.py,sha256=N_P5NadFa0usO0M9cXXJvKJoZofwcDW0cPSfnwvPEO4,4786
+bioguider/agents/collection_observe_step.py,sha256=n863HrbVANQVeltffjS2zXv-AfVErC8ZEMfb_78hafk,5140
 bioguider/agents/collection_plan_step.py,sha256=Nn0f8AOkEDCDtnhaqE7yCQoi7PVpsHmiUcsIqC0T0dQ,5956
-bioguider/agents/collection_task.py,sha256=ZLUxDgh8OkY5INMfC283RdxEYCZJTksoLDNEMfKg-3s,7865
-bioguider/agents/collection_task_utils.py,sha256=CmOh3HZEocuLj5VZCkLbD6P8O5tzyuyFa8Ykd-1GPGE,5356
-bioguider/agents/common_agent.py,sha256=eGs8m8bjO0dmW6lDIen7DQNdWdHD7j8Udf3XhL1k6vI,5242
-bioguider/agents/common_agent_2step.py,sha256=Vton0RKtmMyEgIIFhnBk4CFU_hynX0LvwREcZ9kvMxQ,7918
+bioguider/agents/collection_task.py,sha256=MjpTYiQQYUpmQf2UOn-dOCZU3kxypc4uOnzd15wb1Ow,7882
+bioguider/agents/collection_task_utils.py,sha256=_e2EebYhl-UYjZ0rHNf2-p32YlstBSffv32suiuT9LI,5386
+bioguider/agents/common_agent.py,sha256=TpfxbYskwuwWrjs1g9RaG7sdA5rOLdiVac7If7uK2sg,4558
+bioguider/agents/common_agent_2step.py,sha256=rGiDzUkmmUIFnmJJxzXK5M5BfIyINHXLZ0pmPRUVqQg,7911
+bioguider/agents/common_conversation.py,sha256=zSRiIbUlif8VMC5ZuFfDTyyf1olg3YyWSnYj_E0_SXg,1649
 bioguider/agents/common_step.py,sha256=GdOCbmj1pwh4etg-futVFYVDQuoUG89DnIrw-B6QbzM,2594
 bioguider/agents/dockergeneration_execute_step.py,sha256=F92jDlkc6KjAvTkX7q1FsCYP8J15SCaNgmwh3YPqfDo,6500
-bioguider/agents/dockergeneration_observe_step.py,sha256=93PO_Y4YyUShVTKRt0nErcjb-xYTcwcZCj7TgniS9t4,6098
+bioguider/agents/dockergeneration_observe_step.py,sha256=Bo5Td0fzMYLbLki0FvwamzqRFOy4eu3AvIUa8oFApE4,6131
 bioguider/agents/dockergeneration_plan_step.py,sha256=SB8tQM9PkIKsD2o1DFD7bedcxz6r6hSy8n_EVK60Fz0,7235
 bioguider/agents/dockergeneration_task.py,sha256=mYmorLKnJ-Jku3Qq_Y_kcSTsbYIo3RiVdD0puxqXY5Q,6221
 bioguider/agents/dockergeneration_task_utils.py,sha256=v7emqrJlVW-A5ZdLmPSdiaMSKCR8uzy9UYzx_1cgzyo,9041
-bioguider/agents/evaluation_installation_task.py,sha256=BMnxmzOj5hQPDsAzkmWO6ITe8q98B8v-rKvIXFfA9BY,11280
-bioguider/agents/evaluation_readme_task.py,sha256=_v7ESqMurOg4UXCGqc1zmaVscBx3QbznrUdAKQH9Zws,22597
-bioguider/agents/evaluation_submission_requirements_task.py,sha256=rFCI6bTl64kRiUkEwbh6Ef1LV-YqrgJhGkHaaqE_Pp8,6647
-bioguider/agents/evaluation_task.py,sha256=4VZ7l8oqcUsgJ2YY6s6mkcJu25DgA1qLXv2kVUm2SgI,12654
+bioguider/agents/evaluation_installation_task.py,sha256=mbPRZK6gVEPt-XjDl76_Q71meqFkofFnGPDMq5csL7I,9496
+bioguider/agents/evaluation_readme_task.py,sha256=l0QJAFEE0eBcF2WTDO3S4qPHCJujHPPkfi29tTZf9nI,25223
+bioguider/agents/evaluation_submission_requirements_task.py,sha256=hlEB3_XTgKiwYLiGaWo1kHLFdYKx4NK3EX73zUzeIQY,7584
+bioguider/agents/evaluation_task.py,sha256=4UrcUCy8UIVLd1NpBpqGgmudqeSK3wWI3Jm8LEYySbY,12661
 bioguider/agents/identification_execute_step.py,sha256=w3IjL8f2WiHCyiLjVSoySnIAXpi1-hK1DLKCnXbAN2Y,5587
-bioguider/agents/identification_observe_step.py,sha256=U-iWDR1AZIUpthEswtMbMkPK4YAbAv2SrvBJAqdKyZo,3988
+bioguider/agents/identification_observe_step.py,sha256=Me5mhEM4e7FGnVFcluNtqfhIxzng6guGIu39xi1TrS8,4341
 bioguider/agents/identification_plan_step.py,sha256=owsTK1NZIuiZL7QPVknJyp9TBRK-mhnuf2RwK4YzaxU,5442
-bioguider/agents/identification_task.py,sha256=hVhgExCv1OPMgOYOGRRJyR3-uiG-VR-OgrvWT6vLn9M,10031
-bioguider/agents/identification_task_utils.py,sha256=nWRK3kCyiglw7576idiDGXEzUBBInkz_w9OsK6OJv2E,599
+bioguider/agents/identification_task.py,sha256=bTbovxxQVpO1TcdcQAxDxwPISuAcXndO7zsvHpJSb64,10147
+bioguider/agents/identification_task_utils.py,sha256=Lf0Rj0L0KSiyJmPAgeSz0vLUFQr6TSFuzgufimEN4H0,630
 bioguider/agents/peo_common_step.py,sha256=iw2c1h7X11WJzSE2tSRg0UAoXH0QOlQDxW9CCzSVMOY,2677
-bioguider/agents/prompt_utils.py,sha256=M-KUqGPhtOyFlDN1yNNZdOxTOPFjACF5VhBFW7gXgSc,17151
+bioguider/agents/prompt_utils.py,sha256=EuR7NkB7PcCgNroeX91fHUSK2X6mLS6vK7RnzyQHAHI,17593
 bioguider/agents/python_ast_repl_tool.py,sha256=o7-4P1h8jS8ikhGSA4CI_OWQ2a0Eg5tEdmuAp_qrO-0,2519
 bioguider/agents/rag_collection_task.py,sha256=r_jPAMjQcC7dIydKxX77UuMqjJ3MiVKswNZ-yNw7yx8,5199
 bioguider/conversation.py,sha256=DIvk_d7pz_guuORByK1eaaF09FAK-8shcNTrbSUHz9Y,1779
@@ -38,13 +39,13 @@ bioguider/rag/data_pipeline.py,sha256=bkJ2IUCgPx_OL2uZtPd6cIBor2VFZEIfGd5kVlmiPj
 bioguider/rag/embedder.py,sha256=jofR8hOj3Aj2IyBQ9y6FeAc84tgq5agbIfCGyFxYpJ8,650
 bioguider/rag/rag.py,sha256=JFPwrJlKDSyd3U3Gce_NSxI5343eNUbqPG9Fs5Pfoq0,4696
 bioguider/settings.py,sha256=BD_iz9aYarxmWUl0XaKl4-D4oTXMhFzljsXLNn2phis,3143
-bioguider/utils/constants.py,sha256=4PbzF-s49M0nNtGsLjxQ9-APaJqNAjCQrE0wunSvPqw,982
+bioguider/utils/constants.py,sha256=0e08fByA7a6V7umHyTc7dbOg9axZT6eIgxX_zh4NXQ0,7728
 bioguider/utils/default.gitignore,sha256=XjPdyO2KV8z8iyuqluaNR_70tBQftMpyKL8HboVNyeI,1605
 bioguider/utils/file_utils.py,sha256=9VfAHsz1UkFPtzAmvWZvPl1TMaKIYNjNlLgsfB8tNjg,3683
 bioguider/utils/gitignore_checker.py,sha256=pOYUwsS9D5014LxcZb0cj3s2CAYaD2uF_pYJpaNKcho,6532
 bioguider/utils/pyphen_utils.py,sha256=cdZc3qphkvMDeL5NiZ8Xou13M_uVNP7ifJ-FwxO-0BE,2680
-bioguider/utils/utils.py,sha256=YP3HXgU_rvYDWkEcTzWGiYZw-mlfVrqGhUGSc0_4Pms,900
-bioguider-0.2.14.dist-info/LICENSE,sha256=qzkvZcKwwA5DuSuhXMOm2LcO6BdEr4V7jwFZVL2-jL4,1065
-bioguider-0.2.14.dist-info/METADATA,sha256=lfzJSRJXpaUVDw9hS_pBHePzzBcXOzQS-BrAXiP49E4,1868
-bioguider-0.2.14.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-bioguider-0.2.14.dist-info/RECORD,,
+bioguider/utils/utils.py,sha256=aWtgdvB04gEiJTfQNK4aQPO1mxv2zRZTbDaGUBy9DFc,2275
+bioguider-0.2.16.dist-info/LICENSE,sha256=qzkvZcKwwA5DuSuhXMOm2LcO6BdEr4V7jwFZVL2-jL4,1065
+bioguider-0.2.16.dist-info/METADATA,sha256=_aiIJAMXdRo04JI5rH-YRDUQT_E3PqvLy4l2YkPKKVk,1868
+bioguider-0.2.16.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+bioguider-0.2.16.dist-info/RECORD,,