adhoc-api 0.1.0__tar.gz

adhoc_api-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: adhoc-api
+Version: 0.1.0
+Summary: Agent automatically figures out how to make API requests given API docs and user query in plain text
+Author: David Samson
+Author-email: david.andrew.engineer@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: archytas (>=1.2.1,<2.0.0)
+Requires-Dist: easyrepl (>=0.1.3,<0.2.0)
+Requires-Dist: google-generativeai (>=0.8.2,<0.9.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Ad-Hoc API
+An [Archytas](https://github.com/jataware/archytas) tool that eses LLMs to interact with APIs given documentation. User explains what they want in plain english, and then the agent (using the APIs docs for context) writes python code to complete the task.
+
+## Installation
+```bash
+pip install adhoc-api
+```
+
+## Usage
+
+This is designed to be paired with an Archytas agent. You may omit the python tool, and the agent should instead return the source code to you rather than running it.
+
+```python
+from adhoc_api import AdHocAPI
+from archytas.react import ReActAgent, FailedTaskError
+from archytas.tools import PythonTool
+from easyrepl import REPL
+
+def main():
+    python = PythonTool()
+    adhoc_api = AdhocApi(run_code=python.run)
+    tools = [adhoc_api, python]
+    agent = ReActAgent(model='gpt-4o', tools=tools, verbose=True)
+
+    # REPL to interact with agent
+    for query in REPL(history_file='.chat'):
+        try:
+            answer = agent.react(query)
+            print(answer)
+        except FailedTaskError as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()
+```

adhoc_api-0.1.0/README.md

@@ -0,0 +1,36 @@
+# Ad-Hoc API
+An [Archytas](https://github.com/jataware/archytas) tool that eses LLMs to interact with APIs given documentation. User explains what they want in plain english, and then the agent (using the APIs docs for context) writes python code to complete the task.
+
+## Installation
+```bash
+pip install adhoc-api
+```
+
+## Usage
+
+This is designed to be paired with an Archytas agent. You may omit the python tool, and the agent should instead return the source code to you rather than running it.
+
+```python
+from adhoc_api import AdHocAPI
+from archytas.react import ReActAgent, FailedTaskError
+from archytas.tools import PythonTool
+from easyrepl import REPL
+
+def main():
+    python = PythonTool()
+    adhoc_api = AdhocApi(run_code=python.run)
+    tools = [adhoc_api, python]
+    agent = ReActAgent(model='gpt-4o', tools=tools, verbose=True)
+
+    # REPL to interact with agent
+    for query in REPL(history_file='.chat'):
+        try:
+            answer = agent.react(query)
+            print(answer)
+        except FailedTaskError as e:
+            print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()
+```

adhoc_api-0.1.0/adhoc_api/__init__.py

@@ -0,0 +1 @@
+from .tool import AdhocApi

adhoc_api-0.1.0/adhoc_api/agent.py

@@ -0,0 +1,205 @@
+import copy
+import yaml
+from google import generativeai as genai
+from google.generativeai import caching
+import pathlib
+import datetime
+from archytas.agent import Agent
+
+import os
+from pathlib import Path
+from typing import Callable
+
+
+import pdb
+
+here = Path(__file__).resolve().parent
+
+
+
+def simple_info(info: dict):
+    print('INFO', info)
+
+def simple_error(error: dict):
+    print('ERROR', error)
+
+
+
+
+class GeminiDrafter:
+    def __init__(self, info: Callable[[dict], None]=simple_info, error: Callable[[dict], None]=simple_error):
+        genai.configure(api_key=os.environ["GEMINI_API_KEY"])
+        self.cache = APICache(f'{here}/api_agent.yaml')
+        self.info = info
+        self.error = error
+
+    def draft_request(self, api: str, query: str) -> str:
+        """Using Gemini, draft source code to make a request to the specified API that fulfills the query."""
+        self.info({'api': api, 'goal': query})
+
+        if api not in self.cache.loaded_apis():
+            self.info({'cache': f'api is not loaded: {api}'})
+            if api not in self.cache.available_apis():
+                self.info({'cache': f'api does not exist: {api}'})
+                return f"The selected API was not in the following list: {self.cache.available_apis()}. Please use one of those."
+            self.info({'cache': f'loading api: {api}'})
+            self.cache.load_api(api)
+        
+        try:
+            agent_response = self.cache.chats[api].send_message(query).text
+            prefixes = ['```python', '```']
+            suffixes = ['```', '```\n']
+            for prefix in prefixes:
+                if agent_response.startswith(prefix):
+                    agent_response = agent_response[len(prefix):]
+            for suffix in suffixes:
+                if agent_response.endswith(suffix):
+                    agent_response = agent_response[:-len(suffix)]
+            agent_response = '\n'.join([
+                'import pandas as pd',
+                'import os',
+                'import json',
+                'import requests',
+                agent_response
+            ])
+        except Exception as e:
+            self.error({'error': str(e)})
+            return f"The agent failed to produce valid code: {str(e)}"
+        
+        return agent_response
+
+
+
+class GPTCodeFinalizer:
+    def __init__(self, info: Callable[[dict], None]=simple_info, error: Callable[[dict], None]=simple_error):
+        self.cache = APICache(f'{here}/api_agent.yaml')
+        self.info = info
+        self.error = error
+
+    async def proofread_code(self, api: str, code: str, agent: Agent) -> str:
+        """Proofreads the code, making syntax corrections, and adjusting according to specific notes about the API"""
+        transformed_code = code
+        syntax_check_prompt: str = self.cache.config.get('syntax_check_prompt','')
+        
+        if syntax_check_prompt != '':
+            transformed_code = await agent.query(syntax_check_prompt.format(code=transformed_code))
+            if transformed_code.strip() != code.strip():
+                self.info({
+                    "message": "GPT has changed the code output from Gemini in the syntax fix step.", 
+                    "gpt": transformed_code, 
+                    "gemini": code}
+                )
+
+        additional_pass_prompt: str = self.cache.cache[api].get('gpt_additional_pass', '')
+        if additional_pass_prompt != '':
+            prior_code = transformed_code
+            transformed_code = await agent.query(
+                additional_pass_prompt.format(code=transformed_code)
+                                      .format_map(self.cache.cache[api])
+            )
+            if transformed_code.strip() != prior_code.strip():
+                self.info({
+                    "message": "GPT has changed the code output from Gemini or the syntax check in the additional pass step.", 
+                    "gpt": transformed_code, 
+                    "prior": prior_code}
+                )
+        return transformed_code
+
+# requires gemini API key initialization done beforehand
+class APICache:
+
+    def __init__(self, api_definition_filepath: str, info: Callable[[dict], None]=simple_info, error: Callable[[dict], None]=simple_error):
+        self.cache: dict[str, dict] = {}
+        self.chats: dict[str, genai.ChatSession] = {}
+        self.models: dict[str, genai.GenerativeModel] = {}
+        self.config: dict[str, dict] = {}
+        self.info = info
+        self.error = error
+
+        with open(api_definition_filepath, 'r') as f:
+            try:
+                contents = yaml.safe_load(f)
+                self.config = contents['config']
+                api_definitions = contents['apis']
+            except Exception as e:
+                print(f"failed to load API definitions file properly. check filepath and/or format: {str(e)}")
+                return
+        self.cache['default'] = dict(api_definitions['default'])
+        for api_name, definition in api_definitions.items():
+            if api_name == 'default':
+                continue
+            
+            # merge w/ overwriting defaults
+            self.cache[api_name] = copy.deepcopy(self.cache['default'])
+            for key, value in definition.items():
+                if isinstance(value, str | int | list | bool):
+                    self.cache[api_name][key] = value
+                elif isinstance(value, dict):
+                    self.cache[api_name][key] |= value
+            
+            if self.cache[api_name]['disabled']:
+                del self.cache[api_name]
+                continue 
+
+            # fill docs body
+            try:
+                root_folder = pathlib.Path(__file__).resolve().parent
+                filepath = '/'.join([
+                    str(root_folder),
+                    self.config["documentation_root"],
+                    self.cache[api_name]["documentation_file"]
+                ])
+                with open(filepath, 'r') as f:
+                    self.cache[api_name]['docs'] = f.read()
+            except Exception as e:
+                raise ValueError(f"failed to open docs for api {api_name}: file path {self.cache[api_name]['documentation_file']}: {str(e)}")
+            
+            # formatting interpolations - don't format API docs though.
+            self.cache[api_name] = {
+                k: v.format_map(self.cache[api_name]) 
+                    if isinstance(v, str) else v
+                for k, v in self.cache[api_name].items() 
+                    if k not in self.config['deferred_formatting_fields'] 
+            }
+        del self.cache['default']
+
+    def available_apis(self) -> dict[str, str]:
+        """Returns a mapping of available APIs to their descriptions and full, human readable names."""
+        return {key: f"{self.cache[key]['name']}: {self.cache[key]['description']}" for key in self.cache.keys()}
+
+    def available_api_context(self) -> str:
+        """Nicer formatting for a system prompt of APIs and their descriptions."""
+        return "\n".join([f'    - {k}: {v}' for k, v in self.available_apis().items()])
+
+    def loaded_apis(self):
+        """Returns a list of loaded APIs."""
+        return self.chats.keys()
+
+    def load_api(self, api_name: str):
+        if api_name not in self.available_apis():
+            raise ValueError("requested API is not in available APIs - check definitions file and API name")
+        content = caching.CachedContent.list()
+        is_cached = False
+        for cache_object in content: 
+            if cache_object.display_name == self.cache[api_name]['cache']['key']:
+                is_cached = True
+                self.info({'cache': f'found cached content for {api_name}'})
+                break
+        if not is_cached:
+            cache_object = self.build_cache(api_name)
+        self.models[api_name] = genai.GenerativeModel.from_cached_content(cached_content=cache_object)
+        self.chats[api_name] = self.models[api_name].start_chat()
+
+    def build_cache(self, api_name):
+        if api_name not in self.available_apis():
+            raise ValueError("requested API is not in available APIs - check definitions file and API name")
+        self.info({'cache': f'building cache for {api_name}'})
+        api = self.cache[api_name]
+        cache = caching.CachedContent.create(
+            model=api['cache']['model'],
+            display_name=api['cache']['key'],
+            contents=[api['cache_body']],
+            ttl=datetime.timedelta(minutes=api['cache']['ttl']),
+            system_instruction=api['system_prompt']
+        )
+        return cache

adhoc_api-0.1.0/adhoc_api/api_agent.yaml

@@ -0,0 +1,160 @@
+config:
+    # prepended with the containing folder path - ./ resolves to the current working directory of this file
+    documentation_root: "./api_documentation"
+    # fields that need interpolation at runtime versus at load time 
+    # e.g. prompts that will have variadic input.
+    deferred_formatting_fields: ['docs', 'gpt_additional_pass', 'syntax_check_prompt']
+    # can be disabled by being left blank or omitted.
+    # use {code} for the secondary agent output.
+    syntax_check_prompt: |
+        The code you received is will be listed below the line of dashes.
+        Please fix the python code for syntax errors and only return the python code with fixed syntax errors.
+        Ensure the output has no formatting and return just the code, please.
+
+        If the output has formatting like backticks or a language specifier, be sure to remove all formatting
+        and return nothing but the code itself with no additional text.
+                                            
+        Example:
+            Input:
+                ```python
+                print(a)
+                ```
+            Output:
+                print(a)
+            Input:
+                ```python
+                de f fn_b(b):
+                    print(this is an unescaped string)
+                def fn_a(a):
+                    print(a)
+                ```
+                This code has been fixed to correctly solve the task.
+            Output:
+                def fn_b(b):
+                    print("this is an unescaped string")
+                def fn(a):
+                    print(a)
+        ----------
+        {code}
+
+apis:
+    # if a field is not specified, the default field will be used.
+    # fields can be referenced by python f-string syntax for interpolation.
+    # be sure to use | for block strings so that new lines are given to the prompt.
+    default:
+        # user-visible name
+        name: "Default API"
+        # description provided to the agent
+        description: ''
+        # should this API be disabled
+        # (the default value for any given user-defined api is to be enabled 
+        #   - here, default is handled specially as if the "api" was disabled.)
+        disabled: false
+        cache: 
+            # key -- no default specified! it is required to be manually filled.
+            model: "models/gemini-1.5-flash-001"
+            ttl: 30 # in minutes
+        # relative to config.documentation_root
+        documentation_file: "api_docs.md"
+        # docs is a special field added at load time, populated with the contents of documentation above.
+        docs: "" 
+        system_prompt: |
+            You are an assistant who will help me query the {name} API. 
+            You should write clean python code to solve specific queries I pose. 
+            You should write it as though it will be directly used in a Jupyter notebook. 
+            You should not include backticks or 'python' at the top of the code blocks, that is unnecessary. 
+            You should not provide explanation unless I ask a follow up question. 
+            Assume pandas is installed and is imported with `import pandas as pd`. 
+            Also assume `requests`, `json`, and `os` are imported properly.
+        cache_body: |
+            You will be given the entire API documentation. 
+            When you write code against this API, you should avail yourself of the appropriate query parameters, 
+            your understanding of the response model, and be cognizant that not all data is public and thus may require a token, etc.
+            Unless you receive a 403 forbidden, assume the endpoints are unauthenticated.
+            If the user says the API does not require authentication, OMIT code about tokens and token handling and token headers.
+            When you are downloading, communicate via stdout that something has been downloaded.
+            When you are doing complex things try to break them down step by step and implement appropriate exception handling.
+            {additional_cache_body}
+            Here is the documentation.
+            {docs}
+        # inserted after preamble but above full documentation. 
+        # useful for slight changes without fully replacing the text.
+        additional_cache_body: ''
+        # if present and a non-empty string, instructions for gpt to observe code output before running to fix enum mistakes
+        # use {code} to interpolate the output. this code can also interpolate other things from the API.
+        gpt_additional_pass: ''
+
+    gdc:
+        name: "Genomics Data Commons"
+        description: |
+            The NCI's Genomic Data Commons (GDC) provides the cancer research community with a repository and computational 
+            platform for cancer researchers who need to understand cancer, its clinical progression, and response to therapy.
+            The GDC supports several cancer genome programs at the NCI Center for Cancer Genomics (CCG), 
+            including The Cancer Genome Atlas (TCGA) and Therapeutically Applicable Research to Generate Effective Treatments (TARGET).
+        documentation_file: "gdc.md"
+        cache: 
+            key: "api_assistant_gdc"
+        # for brevity, we define `disease_types` below and use it to avoid repetition.
+        gpt_additional_pass: |
+            You will be provided generated code that often has a problem with an invalid filter for disease types.
+            Please correct the usage of the disease type filters to one of the closest valid disease types 
+            if it is not in the below list.
+
+            The list is provided between the lines.
+            ---------------
+            {disease_types}
+            --------------- 
+
+            The code will now be provided below.
+
+            {code}
+        # custom variables can be defined for formatting.
+        disease_types: |
+                - adenomas and adenocarcinomas
+                - ductal and lobular neoplasms
+                - myeloid leukemias
+                - epithelial neoplasms, nos
+                - squamous cell neoplasms
+                - gliomas
+                - lymphoid leukemias
+                - cystic, mucinous and serous neoplasms
+                - nevi and melanomas
+                - neuroepitheliomatous neoplasms
+                - acute lymphoblastic leukemia
+                - plasma cell tumors
+                - complex mixed and stromal neoplasms
+                - mature b-cell lymphomas
+                - transitional cell papillomas and carcinomas
+                - not applicable
+                - osseous and chondromatous neoplasms
+                - germ cell neoplasms
+                - mesothelial neoplasms
+                - not reported
+                - acinar cell neoplasms
+                - paragangliomas and glomus tumors
+                - chronic myeloproliferative disorders
+                - neoplasms, nos
+                - thymic epithelial neoplasms
+                - myomatous neoplasms
+                - complex epithelial neoplasms
+                - soft tissue tumors and sarcomas, nos
+                - lipomatous neoplasms
+                - meningiomas
+                - fibromatous neoplasms
+                - specialized gonadal neoplasms
+                - unknown
+                - miscellaneous tumors
+                - adnexal and skin appendage neoplasms
+                - basal cell neoplasms
+                - mucoepidermoid neoplasms
+                - myelodysplastic syndromes
+                - nerve sheath tumors
+                - leukemias, nos
+                - synovial-like neoplasms
+                - fibroepithelial neoplasms
+                - miscellaneous bone tumors
+                - blood vessel tumors
+                - mature t- and nk-cell lymphomas
+                - _missing
+
+    

adhoc_api-0.1.0/adhoc_api/default_payload.json

@@ -0,0 +1 @@
+{}

adhoc_api-0.1.0/adhoc_api/test.py

@@ -0,0 +1,29 @@
+from archytas.react import ReActAgent, FailedTaskError
+from archytas.tools import PythonTool
+from easyrepl import REPL
+from .tool import AdhocApi
+
+import pdb
+
+def main():
+    python = PythonTool()
+    adhoc_api = AdhocApi(run_code=python.run)
+
+    tools = [adhoc_api, python]
+    agent = ReActAgent(model='gpt-4o', tools=tools, verbose=True)
+    print(agent.prompt)
+
+    # REPL to interact with agent
+    for query in REPL(history_file='.chat'):
+        try:
+            answer = agent.react(query)
+            print(answer)
+        except FailedTaskError as e:
+            print(f"Error: {e}")
+
+
+
+
+if __name__ == "__main__":
+    main()
+

adhoc_api-0.1.0/adhoc_api/tests/queries_(processed).txt

@@ -0,0 +1,8 @@
+Find gene expression data (raw microarray data, bulk RNA-seq, or scRNA-seq data) from pheochromocytoma and paraganglioma cancer samples.  Download metadata about these patient cases, specimens, microarray data files, and sequencing data files.
+Find WGS and WXS data (aligned reads) from normal tissue samples from patients with neuroblastomas. Include patients with ganglioneuroblastomas. Download metadata about these patient cases, specimens, and sequencing data files.
+Find lung cancer specimens with processed gene copy number and gene expression quantification data. Download metadata about the patient cases, specimens, gene copy number, and gene expression data files.
+Find gene expression data (single-cell RNA-seq, bulk RNA-seq, or RNA microarray data) from glioma patient samples. Download metadata about these patient cases, specimens, and sequencing data files.
+Find gene expression data (RNA-seq, scRNA-seq, or RNA microarray data) from colorectal cancer samples. Include cancer samples from sites within the colon and rectum. Download metadata about these patient cases, specimens, and sequencing data files.
+Find patient cases with whole genome sequencing data, whole exome sequencing data, and/or RNA sequencing data from both normal tissue and tumor samples from patients diagnosed with neuroblastoma. Download metadata about these patient cases, specimens, and sequencing data files. Include only raw and aligned sequencing read data files. Include only patients with a diagnosis of neuroblastoma (including Central neuroblastoma and Neuroblastoma, NOS) and do not include patients diagnosed with ganglioneuroblastomas and cases with neuroblastoma in combination with other cancer types.
+Find patient cases with cancer samples with BAM files from whole transcriptome (RNA-Seq), whole exome (WESeq), and/or whole genome (WGSeq) sequencing data for the following pediatric cancer types: Acute Lymphoblastic Leukemia (ALL), Acute Myeloid Leukemia (AML), Neuroblastoma (NBL), Kidney Tumors (WT, RT, CCSK), and Osteosarcoma (OS). Include only pediatric cases, where age at diagnosis is 20 years old or less, if that data is available. Download metadata about these patient cases, specimens, and BAM sequencing data files. Include BAM sequencing files from normal tissue samples from these patients if available, in addition to those from cancer samples.
+Find patient cases with tumor samples with both processed protein abundance data (this does not need to include abundance data for phosphorylated or acetylated forms) and genomic data for identifying single nucleotide polymorphisms (either whole genome sequencing data or genotyping array data).  Download metadata about these patient cases, specimens, processed protein abundance data files, and genomic data files.

adhoc_api-0.1.0/adhoc_api/tests/queries_(raw).txt

@@ -0,0 +1,8 @@
+I need more gene expression data to supplement the data from the small number of samples in my study. I want microarray and/or RNA-seq data from Pheochromocytomas and Paragangliomas samples. I will use this data to identify cancer subtypes and genes that are differentially expressed between metastatic and non-metastatic cases.
+I want to identify germline variants associated with neuroblastoma cases. I will identify SNPs and insertion/deletion variants in cancer predisposition genes. For this, I want WGS or WES data from normal tissue samples taken from patients with neuroblastomas.
+I want to understand the role of the protein MCL-1 in lung cancer, and would like to investigate the relationship between MCL-1 gene copy number and mRNA expression levels in lung cancer samples.
+In two types of brain stem cell lines, we observed differential gene expression of FOSL1. We would like to test whether this pattern is also observed between brain cancer types in patient samples. For this, we want gene expression data from glioma patient samples.
+We plan to use machine learning to identify critical differentially expressed genes in colorectal cancer. We want whole-transcriptome profiling datasets from CRC samples. We would also like patient data if available to characterize our study sample.
+I am looking for whole genome or whole exome sequencing data, as well as RNA sequencing data, from normal tissue and tumor samples from Neuroblastoma patient cases. I am investigating germline DNA variations in cancer predisposition genes associated with Neuroblastoma risk.
+I want access to BAM files from whole transcriptome (RNA-Seq), whole exome (WESeq), and whole genome (WGSeq) sequencing data across all pediatric cancer types, including Acute Lymphoblastic Leukemia (ALL), Acute Myeloid Leukemia (AML), Neuroblastoma (NBL), Kidney Tumors (WT, RT, CCSK), and Osteosarcoma (OS). I plan to use this data to detect expression and splice junctions in pediatric tumors and identify genetic variants affecting splicing, with the aim of studying associations with clinical factors and outcomes. 
+We are seeking genomic variation (SNP data) and protein abundance data from cancer samples from the same patients to conduct genome-wide association studies (GWAS) and generate protein quantitative trait loci (pQTLs). Ultimately, we aim to utilize proteome-wide Mendelian randomization to investigate potential causal links between various proteins and the development or progression of cancer.

adhoc_api-0.1.0/adhoc_api/tool.py

@@ -0,0 +1,72 @@
+# import asyncio
+
+from archytas.tool_utils import AgentRef, LoopControllerRef, ReactContextRef, tool
+from .agent import GeminiDrafter, GPTCodeFinalizer
+from pathlib import Path
+from typing import Callable, Any
+
+here = Path(__file__).resolve().parent
+
+
+def simple_info(info: dict):
+    print('INFO', info)
+
+def simple_error(error: dict):
+    print('ERROR', error)
+
+
+
+
+class AdhocApi:
+    def __init__(self, *, run_code: Callable[[str], Any]|None=None, info: Callable[[dict], None]=simple_info, error: Callable[[dict], None]=simple_error):
+        self.info = info
+        self.error = error
+        self.run_code = run_code
+
+        self.drafter = GeminiDrafter(info, error)
+        self.finalizer = GPTCodeFinalizer(info, error)
+
+    @tool
+    async def list_apis(self) -> str:
+        """
+        This tool lists all the APIs available to you.
+
+        Returns:
+            str: A list of the APIs and descriptions
+        """
+        return self.drafter.cache.available_api_context()
+    
+    @tool
+    async def use_api(self, api: str, goal: str, agent: AgentRef) -> str:#, loop: LoopControllerRef, react_context: ReactContextRef) -> str:
+        """
+        This tool provides interaction with external APIs with a second agent.
+        You will query external APIs through this tool.
+        Based on what that code returns and the user's goal, continue to interact with the API to get to that goal.
+
+        The output will either be a summary of the code output or an error. 
+        If it is an error, see if you can modify the code to get it to work, and try running it again.
+
+        Consult the APIs available to you when specifying which to use.
+
+        Args:
+            api (str): The API to query. Must be one of the available APIs.
+            goal (str): The task given to the second agent. If the user states the API is unauthenticated, relay that information here.
+        Returns:
+            str: A summary of the current step being run, along with the collected stdout, stderr, returned result, display_data items, and any
+                 errors that may have occurred, or just an error.
+              
+        """
+        draft_code = self.drafter.draft_request(api, goal)
+        fixed_code = await self.finalizer.proofread_code(api, draft_code, agent)
+        
+        if self.run_code is None:
+            return fixed_code
+
+        try:
+            evaluation = self.run_code(fixed_code)
+        except Exception as e:
+            self.error({'error': str(e)})
+            return f"""
+                The second agent failed to create valid code. Instruct it to rerun. The error was {str(e)}. The code will be provided for fixes or retry.
+                """
+        return evaluation

adhoc_api-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "adhoc-api"
+version = "0.1.0"
+description = "Agent automatically figures out how to make API requests given API docs and user query in plain text"
+authors = ["David Samson <david.andrew.engineer@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+archytas = "^1.2.1"
+google-generativeai = "^0.8.2"
+requests = "^2.32.3"
+pyyaml = "^6.0.2"
+easyrepl = "^0.1.3"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"