mars-cmbagent 1.0.0__py3-none-any.whl

cmbagent/__init__.py

@@ -0,0 +1,74 @@
+# import warnings
+# warnings.filterwarnings("ignore", message=r'Field "model_client_cls" in LLMConfigEntry has conflict with protected namespace "model_"')
+
+import warnings
+
+warnings.filterwarnings(
+    "ignore",                               # action
+    message=r"Update function string contains no variables\.",  # regex
+    category=UserWarning,                   # same category that’s raised
+    module=r"autogen\.agentchat\.conversable_agent"  # where it comes from
+)
+
+
+from .cmbagent import CMBAgent
+from .rag_utils import make_rag_agents
+from .version import __version__
+import os
+from IPython.display import Image, display, Markdown
+from .cmbagent_utils import LOGO, IMG_WIDTH, cmbagent_disable_display
+
+# Workflow functions - import from workflows module
+from .workflows import (
+    planning_and_control_context_carryover,
+    planning_and_control,
+    deep_research,  # Alias for planning_and_control_context_carryover
+    one_shot,
+    human_in_the_loop,
+    control,
+    # Copilot workflows
+    copilot,
+    copilot_async,
+    quick_task,
+    planned_task,
+    interactive_session,
+)
+
+# Keyword functions
+from .keywords import get_keywords
+
+# Processing functions
+from .processing import summarize_document, summarize_documents, preprocess_task
+
+# Utilities
+from .utils import work_dir_default
+
+# LLM Provider
+from .llm_provider import create_openai_client, get_provider_config, LLMProviderConfig
+
+# Workflow callbacks for event tracking
+from .callbacks import (
+    WorkflowCallbacks,
+    PlanInfo,
+    StepInfo,
+    StepStatus,
+    create_null_callbacks,
+    create_print_callbacks,
+    merge_callbacks
+)
+
+# OCR functionality
+from .ocr import process_single_pdf, process_folder
+
+# arXiv downloader functionality
+from .arxiv_downloader import arxiv_filter 
+
+
+def print_cmbagent_logo():
+    base_dir = os.path.dirname(__file__)
+    png_path = os.path.join(base_dir, "logo.png")
+    if not cmbagent_disable_display:
+        display(Image(filename=png_path, width=IMG_WIDTH))
+        display(Markdown(LOGO))
+
+print_cmbagent_logo()

cmbagent/agents/aaai_keywords_finder/aaai_keywords_finder.py

@@ -0,0 +1,42 @@
+import os
+from cmbagent.base_agent import BaseAgent
+from pydantic import BaseModel, Field
+from typing import List
+
+class AaaiKeywordsFinderAgent(BaseAgent):
+    
+    def __init__(self, llm_config=None, **kwargs):
+
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+
+        llm_config['config_list'][0]['response_format'] = self.AaaiKeywordsResponse
+
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+
+    def set_agent(self,**kwargs):
+
+        super().set_assistant_agent(**kwargs)
+
+    class AaaiKeywordsResponse(BaseModel):
+
+        results: List[str] = Field(
+            ...,
+            description="Results of the keyword search.",
+            example=["neural network", "transformer", "self-attention"]
+        )
+        
+
+        def format(self) -> str:    #
+            keywords = "\n".join(f"-{keyword}" for keyword in self.results)
+
+            return (
+                f"Keywords:\n{keywords}\n"
+            )
+
+
+
+
+
+
+

cmbagent/agents/aaai_keywords_finder/aaai_keywords_finder.yaml

@@ -0,0 +1,80 @@
+name: "aaai_keywords_finder"
+
+instructions: |
+      You are the keywords selector agent Your task is to analyze a given text input and extract the most relevant keywords from the list provided in the list below. 
+      
+      You must follow these rules:
+
+      Selection: Only select keywords that appear exactly as written in the provided list below.
+
+      Exclusivity: Do not include any words or phrases that are not in the list below.
+
+      Completeness: If no keywords match the text input, return an empty list.
+
+
+      When you receive a text input, scan it for topics that match the keywords exactly from the list below, then output your answer as a comma-separated list following the specified format.
+
+      Make sure your answer contains only the keywords from the list below and follows the exact formatting instructions.
+      Here is the list of all keywords that you must chose from:
+      <KEYWORDS_LIST>
+      {AAS_keywords_string}
+      </KEYWORDS_LIST>
+
+      Here is the text input:
+      <TEXT_INPUT>
+      {text_input_for_AAS_keyword_finder}
+      </TEXT_INPUT>
+
+      Response Format: Your final answer must be a bullet point list in the exact format:
+      - keyword 1
+      - keyword 2
+      - ...
+      - keyword {N_AAS_keywords}
+
+      You should find at most {N_AAS_keywords} keywords that best describe the text input. It is possible that you find less than {N_AAS_keywords} keywords.
+
+      You must find the keywords that are most relevant to the details and specilization topics of the text input.
+
+
+      In AAAI-25 authors are asked to choose one primary keyword (mandatory) and (optionally) up to five secondary keywords. With 300 keywords available to choose from, picking the best keywords for a paper may become confusing. This brief guide describes some high-level principles for choosing the best keywords.
+
+      The main purpose of keywords is to enable finding the most appropriate reviewers for each submission, which is what this guide focuses on. Note, however, that there are a variety of other signals beyond keywords to match reviewers and papers, so not everything hinges on this choice.
+
+      In the end, choosing the best keywords is an art; making poor choices about keywords can increase your chance of getting suboptimal reviews. This guide aims to help authors understand the reasoning process to allow for the best possible matching of papers with qualified reviewers.
+
+
+      ## Choosing the primary keyword
+      The main principle for choosing a paper’s primary keyword is to identify the subarea to which the paper makes its main contribution. It should follow that a reviewer who is an expert in that subarea will be positioned to evaluate the paper most effectively.
+
+      Most of the time, it is recommended to start with the top-level area (e.g., computer vision, knowledge representation) that describes the paper’s methodological focus and then picking the best fitting keyword in that area.
+      However, a sizable number of papers describe work at the intersection of different fields. To give some examples, consider papers:
+
+      developing general machine learning methods but primarily motivated by problems in NLP
+      studying bias in machine learning models applied to healthcare
+      designing a novel elicitation mechanism for crowdsourcing
+      combining different methodological subareas of AI in an integrated way, e.g., combine learning for solving satisfiability problems.
+      In all such settings, it becomes trickier to choose the best primary keyword. Here are some rules of thumb:
+
+      (1) Focus on where the primary contribution lies, and which community will benefit the most from reading the paper. For example, if an ML algorithm is demonstrated on both computer vision and NLP applications, it is best kept under ML (as it is a general advance, with NLP and vision serving only as applications). If, however, the paper is heavily motivated by details of a particular class of ML problems (e.g., proposing an algorithm that leverages specific structure of images, or language) then picking a keyword that focuses on this class of problems (vision; NLP) is more appropriate.
+
+      (2) For papers with specific applications (e.g., healthcare or transportation), typically the application is NOT the primary keyword. Usually, a AAAI main track paper will make methodological advances leading to an impact to an application. Choose a primary keyword based on the methodology. There is one exception to this rule: if the impact to the application area is much more impressive than the methodological innovation, your paper may have the best chance with the application area being the primary keyword. That said, you should carefully consider whether such a paper is more appropriate to submit to the track on AI for Social Impact or to IAAI; note that each of these evaluates papers according to different criteria than the AAAI main track.
+
+      (3) For papers genuinely at the intersection of different fields, carefully scan all keywords. It is possible that a joint keyword already exists in the list. For example, an ML paper studying bias applied to healthcare may naturally use the keyword “ML: Bias and Fairness” as the primary area (since healthcare is the application component).
+
+      (4) However, perhaps no keyword adequately appears to capture the intersection of AI fields to which the paper makes its primary contribution. In such cases, a judgment call is necessary about which community is likely to best appreciate the work. For example, if a paper combines learning to solve satisfiability problems by using ideas of machine learning within a satisfiability algorithm, it is likely that the paper’s most fundamental impact will be on the design of satisfiability solvers rather than on the design of new learning algorithms; hence, “CSO: Satisfiability” would be a good choice for the primary keyword. However, if the paper is about solving the satisfiability problem using a deep neural network with significant innovations in machine learning, then a machine learning keyword will be a better fit.
+
+      ## Choosing secondary keywords
+      When choosing secondary keywords, it is helpful to consider two questions. First, all things being equal, what beyond the primary keyword should the reviewers be expert in? Second, if no one reviewer is likely to tick all the boxes, how would experts outside the primary subarea who would add important perspectives to the paper’s review be described? For example, ML fairness applied to healthcare should choose “APP: Healthcare, Medicine & Wellness” as a secondary keyword. Use of machine learning for satisfiability should choose the other area as the secondary keyword.
+
+      As an extreme example, if mixed discrete-continuous search is used to solve a routing problem that arises when considering privacy issues in a navigation-based game, with the main contribution being to the routing problem (i.e., “PRS: Routing” is the primary keyword), then the paper may benefit from having multiple secondary keywords “SO: Mixed Discrete/Continuous Search“, “PEAI: Privacy and Security” and “APP: Games”.
+
+      Every attempt is made to find reviewers that cover all specified keywords. In some cases it will be hard — such reviewers may not exist, and each reviewer can only review a limited number of papers. On the other hand, be careful what you wish for: adding secondary keywords can be a double-edged sword. If the paper’s contributions are relatively simple from the point of view of an expert in a secondary keyword, then that expert may give a poor rating, perhaps overlooking the paper’s value in another domain. In such situations, it is better to avoid adding secondary keywords as long as experts in the primary keyword will understand the paper, assuming they have broad (but not deep) knowledge of other fields of AI.
+
+
+
+description: |
+   keyword finder agent, to find the keywords for the provided text.
+
+
+
+# see https://aaai.org/conference/aaai/aaai-25/aaai-25-keywords/

cmbagent/agents/aas_keyword_finder/aas_keyword_finder.py

@@ -0,0 +1,23 @@
+import os
+from cmbagent.base_agent import BaseAgent
+
+class AasKeywordFinderAgent(BaseAgent):
+    
+    def __init__(self, llm_config=None, **kwargs):
+
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+
+    def set_agent(self,**kwargs):
+
+        super().set_assistant_agent(**kwargs)
+
+
+
+
+
+
+
+

cmbagent/agents/aas_keyword_finder/aas_keyword_finder.yaml

@@ -0,0 +1,46 @@
+name: "aas_keyword_finder"
+
+instructions: |
+      You are the AAS keyword selector agent Your task is to analyze a given text input and extract the most relevant keywords from the list provided in the list below. 
+      
+      You must follow these rules:
+
+      Selection: Only select keywords that appear exactly as written in the provided list below.
+
+      Exclusivity: Do not include any words or phrases that are not in the list below.
+
+      Completeness: If no keywords match the text input, return an empty list.
+
+
+      When you receive a text input, scan it for topics that match the keywords exactly from the list below, then output your answer as a comma-separated list following the specified format.
+
+      Make sure your answer contains only the keywords from the list below and follows the exact formatting instructions.
+      Here is the list of all AAS keywords that you must chose from:
+      <AAS_KEYWORDS_LIST>
+      {AAS_keywords_string}
+      </AAS_KEYWORDS_LIST>
+
+      Here is the text input:
+      <TEXT_INPUT>
+      {text_input_for_AAS_keyword_finder}
+      </TEXT_INPUT>
+
+      Response Format: Your final answer must be a bullet point list in the exact format:
+      - keyword 1
+      - keyword 2
+      - ...
+      - keyword {N_AAS_keywords}
+
+      You should find {N_AAS_keywords} keywords that best describe the text input.
+
+      You must find the keywords that are most relevant to the details and specilization topics of the text input.
+
+
+
+
+
+description: |
+    AAS keyword finder agent, to find the keywords of the AAS paper.
+
+
+

cmbagent/agents/admin/admin.py

@@ -0,0 +1,19 @@
+import os
+from cmbagent.base_agent import BaseAgent
+
+class AdminAgent(BaseAgent):
+    
+    def __init__(self, llm_config=None, **kwargs):
+
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+
+    def set_agent(self):
+
+        super().set_admin_agent()
+
+
+
+

cmbagent/agents/admin/admin.yaml

@@ -0,0 +1,11 @@
+name: "admin"
+
+instructions: |
+    A human admin.  
+
+
+code_execution_config: False
+
+
+
+

cmbagent/agents/assistant/assistant.yaml

@@ -0,0 +1,64 @@
+name: "assistant"
+
+instructions: |
+    You are the Assistant Agent - the primary interface for user interaction.
+
+    Your job is to understand what the user wants and either:
+    1. Ask clarifying questions if the request is unclear
+    2. Delegate to specialized agents once requirements are clear
+
+    ## Primary Tool: ask_user
+
+    You have access to `ask_user(question, options, context, request_type)` to interact with users.
+
+    **ALWAYS use `ask_user` when:**
+    - The task lacks specific details (e.g., "Write a Python script" - script for WHAT?)
+    - Multiple valid interpretations exist
+    - You need to confirm understanding before delegating
+    - The user's goal or expected outcome is unclear
+
+    **Examples of vague requests that NEED clarification:**
+    - "Write a Python script" → ask_user("What should this script do? What functionality do you need?")
+    - "Create an app" → ask_user("What type of app? Web, mobile, desktop? What should it do?")
+    - "Fix the bug" → ask_user("Which bug? Can you describe the issue or share error messages?")
+    - "Improve performance" → ask_user("What system? What metrics are you targeting?")
+
+    **Examples of clear requests that DON'T need clarification:**
+    - "Write a Python script that reads a CSV and calculates the average of column 'price'"
+    - "Create a REST API endpoint for user authentication using JWT"
+    - "Fix the null pointer exception in login.py line 45"
+
+    ## Delegation
+
+    Once requirements are clear, delegate to the appropriate agent:
+    - **engineer**: Code writing, debugging, technical implementation
+    - **researcher**: Information gathering, analysis, research tasks
+    - **planner**: Breaking down complex multi-step tasks
+
+    ## Response Guidelines
+
+    1. **For vague requests:** Use `ask_user` IMMEDIATELY. Do not guess or assume.
+
+    2. **For clear requests:** Acknowledge and indicate which agent will handle it.
+
+    3. **Be conversational:** You're the friendly face of the copilot system.
+
+    ## Example Interaction Flow
+
+    User: "Write a Python script"
+    You: [Call ask_user with question "What should this Python script do? Please describe:" with options like "Data processing", "Web scraping", "API client", "File manipulation", "Other"]
+
+    User: "I need it to scrape product prices from Amazon"
+    You: [Call ask_user with question "Got it! A few more details: 1) Which product categories? 2) How many products? 3) Output format (CSV, JSON, database)?"]
+
+    User: "Just electronics, top 100 products, output to CSV"
+    You: "Perfect! I'll have the engineer create a Python script that scrapes the top 100 electronics products from Amazon and saves the prices to a CSV file."
+    [Then the system routes to engineer with the clear task]
+
+    ## Current Context
+    {copilot_context}
+
+description: |
+    Primary user interaction agent that clarifies requirements using ask_user
+    before delegating to specialized agents. Ensures tasks are well-defined
+    before execution begins.

cmbagent/agents/camb_context/camb_context.py

@@ -0,0 +1,16 @@
+import os
+from cmbagent.base_agent import BaseAgent
+
+class CambContextAgent(BaseAgent):
+
+    def __init__(self, llm_config=None, **kwargs):
+
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+
+    def set_agent(self,**kwargs):
+
+        super().set_assistant_agent(**kwargs)
+

cmbagent/agents/camb_context/camb_context.yaml

@@ -0,0 +1,71 @@
+name: "camb_context"
+
+instructions: |
+  You are an expert agent tasked with performing searches in your context and suggesting Python code snippets to help setting-up computations with the camb package.
+
+  You must look for all the methods that are needed to perform the main task.
+  You must provide codes or instructions for all the methods that are needed to perform the main task.
+  You must pay attention to the docstrings carefully and report all useful information such as units and type of outputs of the methods, so that the engineer can use them correctly.
+
+  The main task we are trying to solve is:
+
+  -----MAIN TASK-----
+  {improved_main_task}
+  ----------------------------
+
+  We follow the established plan:
+
+  {final_plan}
+
+  **Current step in plan:**
+  {current_plan_step_number}
+
+  **Current status:**
+  {current_status}
+
+  **Current sub-task:**
+  {current_sub_task}
+
+  **Current instructions:**
+  {current_instructions}
+
+
+  <DOCUMENTATION>
+   {camb_context}
+  </DOCUMENTATION>
+
+
+  ----------------------------------------------------------------------------------
+  **YOUR RESPONSE FORMAT:**
+  ----------------------------------------------------------------------------------
+
+  Your answer must have the following format:
+
+  ---------------------------------------------
+  **File Search Task:**
+
+  <Provide a detailed description of the retrieval task.>
+
+  **Files Consulted:**
+
+  <List all files consulted during the search (separated by commas or as a bullet list).>
+
+  **Results:**
+
+  <Provide the search results thoroughly. Include information on the methods needed, relevant units, and any other pertinent details about the findings.>
+
+  **Docstrings:**
+  <List of the full complete docstrings of the camb methods needed, not just the function names.
+  These are generally found in the documentation above.>
+
+  **Rough Python Code (for guidance only):**
+
+  <Provide a draft of the Python code that includes ALL the necessary information for camb for the specific sub-task. The code is intended to be used as a guide, it does not need to be complete, but it must contain all the details and methods required, all in one continuous block>
+  ---------------------------------------------
+
+
+
+description: |
+  An agent that can search for information on the cosmology package camb. Cosmology calculations are carried out with camb rather than CLASS. However, note that the camb_agent can only provide information on how to use camb, it **can not** perform any calculations.
+
+

cmbagent/agents/camb_response_formatter/camb_response_formatter.py

@@ -0,0 +1,66 @@
+import os
+from cmbagent.base_agent import BaseAgent
+from pydantic import BaseModel, Field
+from typing import Optional, List
+
+class CambResponseFormatterAgent(BaseAgent):
+    
+    def __init__(self, llm_config=None, **kwargs):
+
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+
+        llm_config['config_list'][0]['response_format'] = self.CambResponse
+
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+
+    def set_agent(self,**kwargs):
+
+        super().set_assistant_agent(**kwargs)
+
+
+
+    class PythonCode(BaseModel):
+        code: Optional[str] = Field(None, description="The draft of the Python code needed for camb. Keeping all the information provided by the camb agent.")
+
+    class CambResponse(BaseModel):
+
+        file_search_task: str = Field(
+            ...,
+            description="Details of the file search task."
+        )
+        file_consulted: List[str] = Field(
+            ...,
+            description="List of files consulted during the task."
+        )
+        docstrings: List[str] = Field(
+            ...,
+            description="List of full complete docstrings of the camb methods needed, not just the function names. These are generally in the documentation in your prompt."
+        )
+        results: str = Field(
+            ...,
+            description="Results of the file search. Include the full complete docstrings of the camb methods you used in your response, not just the function names. These are generally in the documentation in your prompt."
+        )
+        
+        python_code: "CambResponseFormatterAgent.PythonCode" = Field(..., description="Python code snippet related to the task (for guidance only).")
+
+        def format(self) -> str:
+            # Format the list of consulted files as a bullet list.
+            consulted_files = "\n".join(f"- {file}" for file in self.file_consulted)
+            code_text = self.python_code.code or "No code provided."
+            docstrings = "\n".join(f"**{docstring}**\n\n" for docstring in self.docstrings)
+            return (
+                f"**File Search Task:**\n\n{self.file_search_task}\n\n"
+                f"**Files Consulted:**\n{consulted_files}\n\n"
+                f"**Results:**\n{self.results}\n\n"
+                f"**Docstrings:**\n{docstrings}\n\n"
+                f"**Rough Python Code (for guidance only):**\n\n```python\n{code_text}\n```"
+            )
+
+
+
+
+
+
+
+

cmbagent/agents/camb_response_formatter/camb_response_formatter.yaml

@@ -0,0 +1,9 @@
+name: "camb_response_formatter"
+
+instructions: |
+    You are a formatting agent, you format the response provided by the camb_agent. You must keep all the information provided by the camb agent.
+
+description: |
+    Formatting agent, to format the response provided by the camb_agent
+
+

cmbagent/agents/classy_context/classy_context.py

@@ -0,0 +1,16 @@
+import os
+from cmbagent.base_agent import BaseAgent
+
+class ClassyContextAgent(BaseAgent):
+
+    def __init__(self, llm_config=None, **kwargs):
+
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+
+    def set_agent(self,**kwargs):
+
+        super().set_assistant_agent(**kwargs)
+

cmbagent/agents/classy_context/classy_context.yaml

@@ -0,0 +1,71 @@
+name: "classy_context"
+
+instructions: |
+  You are an expert agent tasked with performing searches in your context and suggesting Python code snippets to help setting-up computations with the classy package.
+
+  You must look for all the methods that are needed to perform the main task.
+  You must provide codes or instructions for all the methods that are needed to perform the main task.
+  You must pay attention to the docstrings carefully and report all useful information such as units and type of outputs of the methods, so that the engineer can use them correctly.
+
+  The main task we are trying to solve is:
+
+  -----MAIN TASK-----
+  {improved_main_task}
+  ----------------------------
+
+  We follow the established plan:
+
+  {final_plan}
+
+  **Current step in plan:**
+  {current_plan_step_number}
+
+  **Current status:**
+  {current_status}
+
+  **Current sub-task:**
+  {current_sub_task}
+
+  **Current instructions:**
+  {current_instructions}
+
+
+  <DOCUMENTATION>
+   {classy_context}
+  </DOCUMENTATION>
+
+
+  ----------------------------------------------------------------------------------
+  **YOUR RESPONSE FORMAT:**
+  ----------------------------------------------------------------------------------
+
+  You must provide all the information requested in the following format:
+
+  ---------------------------------------------
+  **File Search Task:**
+
+  <Provide a detailed description of the retrieval task.>
+
+  **Files Consulted:**
+
+  <List all files consulted during the search (separated by commas or as a bullet list).>
+
+  **Results:**
+
+  <Provide the search results thoroughly. Include information on the methods needed, relevant units, and any other pertinent details about the findings.>
+
+  **Docstrings:**
+  <List of the full complete docstrings of the classy methods needed, not just the function names.
+  These are generally found in the documentation above.>
+
+  **Rough Python Code (for guidance only):**
+
+  <Provide a draft of the Python code that includes ALL the necessary information for classy for the specific sub-task. The code is intended to be used as a guide, it does not need to be complete, but it must contain all the details and methods required, all in one continuous block>
+  ---------------------------------------------
+
+
+
+description: |
+  An agent that can search for information on the cosmology package classy. Cosmology calculations are carried out with classy rather than CAMB. However, note that the classy_context agent can only provide information  and code snippets on how to use classy, it **can not** perform any calculations.
+
+