futurehouse-client 0.3.16__tar.gz → 0.3.17.dev94__tar.gz

{futurehouse_client-0.3.16 → futurehouse_client-0.3.17.dev94}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: futurehouse-client
-Version: 0.3.16
+Version: 0.3.17.dev94
 Summary: A client for interacting with endpoints of the FutureHouse service.
 Author-email: FutureHouse technical staff <hello@futurehouse.org>
 Classifier: Operating System :: OS Independent
@@ -19,6 +19,7 @@ Requires-Dist: litellm==1.67.4.post1
 Requires-Dist: pydantic
 Requires-Dist: python-dotenv
 Requires-Dist: tenacity
+Requires-Dist: tqdm>=4.62
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: jupyter; extra == "dev"
@@ -30,6 +31,7 @@ Requires-Dist: pylint; extra == "dev"
 Requires-Dist: pylint-per-file-ignores; extra == "dev"
 Requires-Dist: pylint-pydantic; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: pytest-rerunfailures; extra == "dev"
 Requires-Dist: pytest-subtests; extra == "dev"
 Requires-Dist: pytest-timeout; extra == "dev"
@@ -49,9 +51,9 @@ Documentation and tutorials for futurehouse-client, a client for interacting wit
 - [Quickstart](#quickstart)
 - [Functionalities](#functionalities)
 - [Authentication](#authentication)
-- [Task submission](#task-submission)
+- [Simple task running](#simple-task-running)
 - [Task Continuation](#task-continuation)
-- [Task retrieval](#task-retrieval)
+- [Asynchronous tasks](#asynchronous-tasks)
 
 <!--TOC-->
 
@@ -78,19 +80,17 @@ task_data = {
     "query": "Which neglected diseases had a treatment developed by artificial intelligence?",
 }
 
-task_run_id = client.create_task(task_data)
-
-task_status = client.get_task(task_run_id)
+task_response = client.run_tasks_until_done(task_data)
 ```
 
-A quickstart example can be found in the [client_notebook.ipynb](https://github.com/Future-House/futurehouse-client-docs/blob/main/docs/client_notebook.ipynb) file, where we show how to submit and retrieve a job task, pass runtime configuration to the agent, and ask follow-up questions to the previous job.
+A quickstart example can be found in the [client_notebook.ipynb](https://futurehouse.gitbook.io/futurehouse-cookbook/futurehouse-client/docs/client_notebook) file, where we show how to submit and retrieve a job task, pass runtime configuration to the agent, and ask follow-up questions to the previous job.
 
 ## Functionalities
 
 FutureHouse client implements a RestClient (called `FutureHouseClient`) with the following functionalities:
 
-- [Task submission](#task-submission): `create_task(TaskRequest)`
-- [Task status](#task-status): `get_task(task_id)`
+- [Simple task running](#simple-task-running): `run_tasks_until_done(TaskRequest)` or `await arun_tasks_until_done(TaskRequest)`
+- [Asynchronous tasks](#asynchronous-tasks): `get_task(task_id)` or `aget_task(task_id)` and `create_task(TaskRequest)` or `acreate_task(TaskRequest)`
 
 To create a `FutureHouseClient`, you need to pass an FutureHouse platform api key (see [Authentication](#authentication)):
 
@@ -106,9 +106,9 @@ client = FutureHouseClient(
 
 In order to use the `FutureHouseClient`, you need to authenticate yourself. Authentication is done by providing an API key, which can be obtained directly from your [profile page in the FutureHouse platform](https://platform.futurehouse.org/profile).
 
-## Task submission
+## Simple task running
 
-In the futurehouse platform, we define the deployed combination of an agent and an environment as a `job`. To invoke a job, we need to submit a `task` (also called a `query`) to it.
+In the FutureHouse platform, we define the deployed combination of an agent and an environment as a `job`. To invoke a job, we need to submit a `task` (also called a `query`) to it.
 `FutureHouseClient` can be used to submit tasks/queries to available jobs in the FutureHouse platform. Using a `FutureHouseClient` instance, you can submit tasks to the platform by calling the `create_task` method, which receives a `TaskRequest` (or a dictionary with `kwargs`) and returns the task id.
 Aiming to make the submission of tasks as simple as possible, we have created a `JobNames` `enum` that contains the available task types.
 
@@ -118,10 +118,10 @@ The available supported jobs are:
 | `JobNames.CROW` | `job-futurehouse-paperqa2` | Fast Search | Ask a question of scientific data sources, and receive a high-accuracy, cited response. Built with [PaperQA2](https://github.com/Future-House/paper-qa). |
 | `JobNames.FALCON` | `job-futurehouse-paperqa2-deep` | Deep Search | Use a plethora of sources to deeply research. Receive a detailed, structured report as a response. |
 | `JobNames.OWL` | `job-futurehouse-hasanyone` | Precedent Search | Formerly known as HasAnyone, query if anyone has ever done something in science. |
+| `JobNames.PHOENIX` | `job-futurehouse-phoenix` | Chemistry Tasks | A new iteration of ChemCrow, Phoenix uses cheminformatics tools to do chemistry. Good for planning synthesis and design of new molecules. |
 | `JobNames.DUMMY` | `job-futurehouse-dummy` | Dummy Task | This is a dummy task. Mainly for testing purposes. |
 
-Using `JobNames`, the client automatically adapts the job name to the current stage.
-The task submission looks like this:
+Using `JobNames`, the task submission looks like this:
 
 ```python
 from futurehouse_client import FutureHouseClient, JobNames
@@ -135,10 +135,73 @@ task_data = {
     "query": "Has anyone tested therapeutic exerkines in humans or NHPs?",
 }
 
-task_id = client.create_task(task_data)
+task_response = client.run_tasks_until_done(task_data)
+
+print(task_response.answer)
+```
+
+Or if running async code:
+
+```python
+import asyncio
+from futurehouse_client import FutureHouseClient, JobNames
+
+
+async def main():
+    client = FutureHouseClient(
+        api_key="your_api_key",
+    )
+
+    task_data = {
+        "name": JobNames.OWL,
+        "query": "Has anyone tested therapeutic exerkines in humans or NHPs?",
+    }
+
+    task_response = await client.arun_tasks_until_done(task_data)
+    print(task_response.answer)
+    return task_id
+
+
+# For Python 3.7+
+if __name__ == "__main__":
+    task_id = asyncio.run(main())
 ```
 
-`TaskRequest` has the following fields:
+Note that in either the sync or the async code, collections of tasks can be given to the client to run them in a batch:
+
+```python
+import asyncio
+from futurehouse_client import FutureHouseClient, JobNames
+
+
+async def main():
+    client = FutureHouseClient(
+        api_key="your_api_key",
+    )
+
+    task_data = [
+        {
+            "name": JobNames.OWL,
+            "query": "Has anyone tested therapeutic exerkines in humans or NHPs?",
+        },
+        {
+            "name": JobNames.CROW,
+            "query": "Are there any clinically validated therapeutic exerkines for humans?",
+        },
+    ]
+
+    task_responses = await client.arun_tasks_until_done(task_data)
+    print(task_responses[0].answer)
+    print(task_responses[1].answer)
+    return task_id
+
+
+# For Python 3.7+
+if __name__ == "__main__":
+    task_id = asyncio.run(main())
+```
+
+`TaskRequest` can also be used to submit jobs and it has the following fields:
 
 | Field          | Type          | Description                                                                                                         |
 | -------------- | ------------- | ------------------------------------------------------------------------------------------------------------------- |
@@ -148,13 +211,67 @@ task_id = client.create_task(task_data)
 | runtime_config | RuntimeConfig | Optional runtime parameters for the job                                                                             |
 
 `runtime_config` can receive a `AgentConfig` object with the desired kwargs. Check the available `AgentConfig` fields in the [LDP documentation](https://github.com/Future-House/ldp/blob/main/src/ldp/agent/agent.py#L87). Besides the `AgentConfig` object, we can also pass `timeout` and `max_steps` to limit the execution time and the number of steps the agent can take.
-Other especialised configurations are also available but are outside the scope of this documentation.
+
+```python
+from futurehouse_client import FutureHouseClient, JobNames
+from futurehouse_client.models.app import TaskRequest
+
+client = FutureHouseClient(
+    api_key="your_api_key",
+)
+
+task_response = client.run_tasks_until_done(
+    TaskRequest(
+        name=JobNames.OWL,
+        query="Has anyone tested therapeutic exerkines in humans or NHPs?",
+    )
+)
+
+print(task_response.answer)
+```
+
+A `TaskResponse` will be returned from using our agents. For Owl, Crow, and Falcon, we default to a subclass, `PQATaskResponse` which has some key attributes:
+
+| Field                 | Type | Description                                                                     |
+| --------------------- | ---- | ------------------------------------------------------------------------------- |
+| answer                | str  | Answer to your query.                                                           |
+| formatted_answer      | str  | Specially formatted answer with references.                                     |
+| has_successful_answer | bool | Flag for whether the agent was able to find a good answer to your query or not. |
+
+If using the `verbose` setting, much more data can be pulled down from your `TaskResponse`, which will exist across all agents (not just Owl, Crow, and Falcon).
+
+```python
+from futurehouse_client import FutureHouseClient, JobNames
+from futurehouse_client.models.app import TaskRequest
+
+client = FutureHouseClient(
+    api_key="your_api_key",
+)
+
+task_response = client.run_tasks_until_done(
+    TaskRequest(
+        name=JobNames.OWL,
+        query="Has anyone tested therapeutic exerkines in humans or NHPs?",
+    ),
+    verbose=True,
+)
+
+print(task_response.environment_frame)
+```
+
+In that case, a `TaskResponseVerbose` will have the following fields:
+
+| Field             | Type | Description                                                                                                            |
+| ----------------- | ---- | ---------------------------------------------------------------------------------------------------------------------- | --- |
+| agent_state       | dict | Large object with all agent states during the progress of your task.                                                   |
+| environment_frame | dict | Large nested object with all environment data, for PQA environments it includes contexts, paper metadata, and answers. |
+| metadata          | dict | Extra metadata about your query.                                                                                       |     |
 
 ## Task Continuation
 
 Once a task is submitted and the answer is returned, FutureHouse platform allow you to ask follow-up questions to the previous task.
 It is also possible through the platform API.
-To accomplish that, we can use the `runtime_config` we discussed in the [Task submission](#task-submission) section.
+To accomplish that, we can use the `runtime_config` we discussed in the [Simple task running](#simple-task-running) section.
 
 ```python
 from futurehouse_client import FutureHouseClient, JobNames
@@ -173,12 +290,12 @@ continued_task_data = {
     "runtime_config": {"continued_task_id": task_id},
 }
 
-continued_task_id = client.create_task(continued_task_data)
+task_result = client.run_tasks_until_done(continued_task_data)
 ```
 
-## Task retrieval
+## Asynchronous tasks
 
-Once a task is submitted, you can retrieve it by calling the `get_task` method, which receives a task id and returns a `TaskResponse` object.
+Sometimes you may want to submit many jobs, while querying results at a later time. In this way you can do other things while waiting for a response. The platform API supports this as well rather than waiting for a result.
 
 ```python
 from futurehouse_client import FutureHouseClient
@@ -187,9 +304,13 @@ client = FutureHouseClient(
     api_key="your_api_key",
 )
 
-task_id = "task_id"
+task_data = {"name": JobNames.CROW, "query": "How many species of birds are there?"}
+
+task_id = client.create_task(task_data)
+
+# move on to do other things
 
 task_status = client.get_task(task_id)
 ```
 
-`task_status` contains information about the task. For instance, its `status`, `task`, `environment_name` and `agent_name`, and other fields specific to the job.
+`task_status` contains information about the task. For instance, its `status`, `task`, `environment_name` and `agent_name`, and other fields specific to the job. You can continually query the status until it's `success` before moving on.

futurehouse_client-0.3.17.dev94/README.md

@@ -0,0 +1,273 @@
+# FutureHouse Platform API Documentation
+
+Documentation and tutorials for futurehouse-client, a client for interacting with endpoints of the FutureHouse platform.
+
+<!--TOC-->
+
+- [Installation](#installation)
+- [Quickstart](#quickstart)
+- [Functionalities](#functionalities)
+- [Authentication](#authentication)
+- [Simple task running](#simple-task-running)
+- [Task Continuation](#task-continuation)
+- [Asynchronous tasks](#asynchronous-tasks)
+
+<!--TOC-->
+
+## Installation
+
+```bash
+uv pip install futurehouse-client
+```
+
+## Quickstart
+
+```python
+from futurehouse_client import FutureHouseClient, JobNames
+from pathlib import Path
+from aviary.core import DummyEnv
+import ldp
+
+client = FutureHouseClient(
+    api_key="your_api_key",
+)
+
+task_data = {
+    "name": JobNames.CROW,
+    "query": "Which neglected diseases had a treatment developed by artificial intelligence?",
+}
+
+task_response = client.run_tasks_until_done(task_data)
+```
+
+A quickstart example can be found in the [client_notebook.ipynb](https://futurehouse.gitbook.io/futurehouse-cookbook/futurehouse-client/docs/client_notebook) file, where we show how to submit and retrieve a job task, pass runtime configuration to the agent, and ask follow-up questions to the previous job.
+
+## Functionalities
+
+FutureHouse client implements a RestClient (called `FutureHouseClient`) with the following functionalities:
+
+- [Simple task running](#simple-task-running): `run_tasks_until_done(TaskRequest)` or `await arun_tasks_until_done(TaskRequest)`
+- [Asynchronous tasks](#asynchronous-tasks): `get_task(task_id)` or `aget_task(task_id)` and `create_task(TaskRequest)` or `acreate_task(TaskRequest)`
+
+To create a `FutureHouseClient`, you need to pass an FutureHouse platform api key (see [Authentication](#authentication)):
+
+```python
+from futurehouse_client import FutureHouseClient
+
+client = FutureHouseClient(
+    api_key="your_api_key",
+)
+```
+
+## Authentication
+
+In order to use the `FutureHouseClient`, you need to authenticate yourself. Authentication is done by providing an API key, which can be obtained directly from your [profile page in the FutureHouse platform](https://platform.futurehouse.org/profile).
+
+## Simple task running
+
+In the FutureHouse platform, we define the deployed combination of an agent and an environment as a `job`. To invoke a job, we need to submit a `task` (also called a `query`) to it.
+`FutureHouseClient` can be used to submit tasks/queries to available jobs in the FutureHouse platform. Using a `FutureHouseClient` instance, you can submit tasks to the platform by calling the `create_task` method, which receives a `TaskRequest` (or a dictionary with `kwargs`) and returns the task id.
+Aiming to make the submission of tasks as simple as possible, we have created a `JobNames` `enum` that contains the available task types.
+
+The available supported jobs are:
+| Alias | Job Name | Task type | Description |
+| --- | --- | --- | --- |
+| `JobNames.CROW` | `job-futurehouse-paperqa2` | Fast Search | Ask a question of scientific data sources, and receive a high-accuracy, cited response. Built with [PaperQA2](https://github.com/Future-House/paper-qa). |
+| `JobNames.FALCON` | `job-futurehouse-paperqa2-deep` | Deep Search | Use a plethora of sources to deeply research. Receive a detailed, structured report as a response. |
+| `JobNames.OWL` | `job-futurehouse-hasanyone` | Precedent Search | Formerly known as HasAnyone, query if anyone has ever done something in science. |
+| `JobNames.PHOENIX` | `job-futurehouse-phoenix` | Chemistry Tasks | A new iteration of ChemCrow, Phoenix uses cheminformatics tools to do chemistry. Good for planning synthesis and design of new molecules. |
+| `JobNames.DUMMY` | `job-futurehouse-dummy` | Dummy Task | This is a dummy task. Mainly for testing purposes. |
+
+Using `JobNames`, the task submission looks like this:
+
+```python
+from futurehouse_client import FutureHouseClient, JobNames
+
+client = FutureHouseClient(
+    api_key="your_api_key",
+)
+
+task_data = {
+    "name": JobNames.OWL,
+    "query": "Has anyone tested therapeutic exerkines in humans or NHPs?",
+}
+
+task_response = client.run_tasks_until_done(task_data)
+
+print(task_response.answer)
+```
+
+Or if running async code:
+
+```python
+import asyncio
+from futurehouse_client import FutureHouseClient, JobNames
+
+
+async def main():
+    client = FutureHouseClient(
+        api_key="your_api_key",
+    )
+
+    task_data = {
+        "name": JobNames.OWL,
+        "query": "Has anyone tested therapeutic exerkines in humans or NHPs?",
+    }
+
+    task_response = await client.arun_tasks_until_done(task_data)
+    print(task_response.answer)
+    return task_id
+
+
+# For Python 3.7+
+if __name__ == "__main__":
+    task_id = asyncio.run(main())
+```
+
+Note that in either the sync or the async code, collections of tasks can be given to the client to run them in a batch:
+
+```python
+import asyncio
+from futurehouse_client import FutureHouseClient, JobNames
+
+
+async def main():
+    client = FutureHouseClient(
+        api_key="your_api_key",
+    )
+
+    task_data = [
+        {
+            "name": JobNames.OWL,
+            "query": "Has anyone tested therapeutic exerkines in humans or NHPs?",
+        },
+        {
+            "name": JobNames.CROW,
+            "query": "Are there any clinically validated therapeutic exerkines for humans?",
+        },
+    ]
+
+    task_responses = await client.arun_tasks_until_done(task_data)
+    print(task_responses[0].answer)
+    print(task_responses[1].answer)
+    return task_id
+
+
+# For Python 3.7+
+if __name__ == "__main__":
+    task_id = asyncio.run(main())
+```
+
+`TaskRequest` can also be used to submit jobs and it has the following fields:
+
+| Field          | Type          | Description                                                                                                         |
+| -------------- | ------------- | ------------------------------------------------------------------------------------------------------------------- |
+| id             | UUID          | Optional job identifier. A UUID will be generated if not provided                                                   |
+| name           | str           | Name of the job to execute eg. `job-futurehouse-paperqa2`, or using the `JobNames` for convenience: `JobNames.CROW` |
+| query          | str           | Query or task to be executed by the job                                                                             |
+| runtime_config | RuntimeConfig | Optional runtime parameters for the job                                                                             |
+
+`runtime_config` can receive a `AgentConfig` object with the desired kwargs. Check the available `AgentConfig` fields in the [LDP documentation](https://github.com/Future-House/ldp/blob/main/src/ldp/agent/agent.py#L87). Besides the `AgentConfig` object, we can also pass `timeout` and `max_steps` to limit the execution time and the number of steps the agent can take.
+
+```python
+from futurehouse_client import FutureHouseClient, JobNames
+from futurehouse_client.models.app import TaskRequest
+
+client = FutureHouseClient(
+    api_key="your_api_key",
+)
+
+task_response = client.run_tasks_until_done(
+    TaskRequest(
+        name=JobNames.OWL,
+        query="Has anyone tested therapeutic exerkines in humans or NHPs?",
+    )
+)
+
+print(task_response.answer)
+```
+
+A `TaskResponse` will be returned from using our agents. For Owl, Crow, and Falcon, we default to a subclass, `PQATaskResponse` which has some key attributes:
+
+| Field                 | Type | Description                                                                     |
+| --------------------- | ---- | ------------------------------------------------------------------------------- |
+| answer                | str  | Answer to your query.                                                           |
+| formatted_answer      | str  | Specially formatted answer with references.                                     |
+| has_successful_answer | bool | Flag for whether the agent was able to find a good answer to your query or not. |
+
+If using the `verbose` setting, much more data can be pulled down from your `TaskResponse`, which will exist across all agents (not just Owl, Crow, and Falcon).
+
+```python
+from futurehouse_client import FutureHouseClient, JobNames
+from futurehouse_client.models.app import TaskRequest
+
+client = FutureHouseClient(
+    api_key="your_api_key",
+)
+
+task_response = client.run_tasks_until_done(
+    TaskRequest(
+        name=JobNames.OWL,
+        query="Has anyone tested therapeutic exerkines in humans or NHPs?",
+    ),
+    verbose=True,
+)
+
+print(task_response.environment_frame)
+```
+
+In that case, a `TaskResponseVerbose` will have the following fields:
+
+| Field             | Type | Description                                                                                                            |
+| ----------------- | ---- | ---------------------------------------------------------------------------------------------------------------------- | --- |
+| agent_state       | dict | Large object with all agent states during the progress of your task.                                                   |
+| environment_frame | dict | Large nested object with all environment data, for PQA environments it includes contexts, paper metadata, and answers. |
+| metadata          | dict | Extra metadata about your query.                                                                                       |     |
+
+## Task Continuation
+
+Once a task is submitted and the answer is returned, FutureHouse platform allow you to ask follow-up questions to the previous task.
+It is also possible through the platform API.
+To accomplish that, we can use the `runtime_config` we discussed in the [Simple task running](#simple-task-running) section.
+
+```python
+from futurehouse_client import FutureHouseClient, JobNames
+
+client = FutureHouseClient(
+    api_key="your_api_key",
+)
+
+task_data = {"name": JobNames.CROW, "query": "How many species of birds are there?"}
+
+task_id = client.create_task(task_data)
+
+continued_task_data = {
+    "name": JobNames.CROW,
+    "query": "From the previous answer, specifically,how many species of crows are there?",
+    "runtime_config": {"continued_task_id": task_id},
+}
+
+task_result = client.run_tasks_until_done(continued_task_data)
+```
+
+## Asynchronous tasks
+
+Sometimes you may want to submit many jobs, while querying results at a later time. In this way you can do other things while waiting for a response. The platform API supports this as well rather than waiting for a result.
+
+```python
+from futurehouse_client import FutureHouseClient
+
+client = FutureHouseClient(
+    api_key="your_api_key",
+)
+
+task_data = {"name": JobNames.CROW, "query": "How many species of birds are there?"}
+
+task_id = client.create_task(task_data)
+
+# move on to do other things
+
+task_status = client.get_task(task_id)
+```
+
+`task_status` contains information about the task. For instance, its `status`, `task`, `environment_name` and `agent_name`, and other fields specific to the job. You can continually query the status until it's `success` before moving on.

{futurehouse_client-0.3.16 → futurehouse_client-0.3.17.dev94}/docs/client_notebook.ipynb

@@ -25,14 +25,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import time\n",
-    "\n",
-    "from futurehouse_client import Client, JobNames\n",
+    "from futurehouse_client import FutureHouseClient, JobNames\n",
     "from futurehouse_client.models import (\n",
     "    AuthType,\n",
-    "    JobRequest,\n",
     "    RuntimeConfig,\n",
     "    Stage,\n",
+    "    TaskRequest,\n",
     ")\n",
     "from ldp.agent import AgentConfig"
    ]
@@ -53,7 +51,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "client = Client(\n",
+    "client = FutureHouseClient(\n",
     "    stage=Stage.PROD,\n",
     "    auth_type=AuthType.API_KEY,\n",
     "    api_key=\"your-api-key\",\n",
@@ -71,7 +69,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Submitting jobs is done by calling the `create_job` method, which receives a `JobRequest` object."
+    "Submitting jobs is done by calling the `run_tasks_until_done` method, which receives a `TaskRequest` object."
    ]
   },
   {
@@ -80,24 +78,22 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "job_data = JobRequest(\n",
+    "task_data = TaskRequest(\n",
     "    name=JobNames.from_string(\"crow\"),\n",
     "    query=\"What is the molecule known to have the greatest solubility in water?\",\n",
     ")\n",
-    "client.create_job(job_data)\n",
+    "task_response = client.run_tasks_until_done(task_data)\n",
     "\n",
-    "while client.get_job().status != \"success\":\n",
-    "    time.sleep(5)\n",
-    "print(f\"Job status: {client.get_job().status}\")\n",
-    "print(f\"Job answer: \\n{client.get_job().formatted_answer}\")"
+    "print(f\"Job status: {task_response.status}\")\n",
+    "print(f\"Job answer: \\n{task_response.formatted_answer}\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can also pass a `runtime_config` to the job, which will be used to configure the agent on runtime.\n",
-    "Here, we will define a agent configuration and pass it to the job. This agent is used to decide the next action to take.\n",
+    "You can also pass a `runtime_config` to the task, which will be used to configure the agent on runtime.\n",
+    "Here, we will define a agent configuration and pass it to the task. This agent is used to decide the next action to take.\n",
     "We will also use the `max_steps` parameter to limit the number of steps the agent will take."
    ]
   },
@@ -114,17 +110,15 @@
     "        \"temperature\": 0.0,\n",
     "    },\n",
     ")\n",
-    "job_data = JobRequest(\n",
+    "task_data = TaskRequest(\n",
     "    name=JobNames.CROW,\n",
     "    query=\"How many moons does earth have?\",\n",
     "    runtime_config=RuntimeConfig(agent=agent, max_steps=10),\n",
     ")\n",
-    "client.create_job(job_data)\n",
+    "task_response = client.run_tasks_until_done(task_data)\n",
     "\n",
-    "while client.get_job().status != \"success\":\n",
-    "    time.sleep(5)\n",
-    "print(f\"Job status: {client.get_job().status}\")\n",
-    "print(f\"Job answer: \\n{client.get_job().formatted_answer}\")"
+    "print(f\"Job status: {task_response.status}\")\n",
+    "print(f\"Job answer: \\n{task_response.formatted_answer}\")"
    ]
   },
   {
@@ -145,13 +139,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "job_data = JobRequest(name=JobNames.CROW, query=\"How many species of birds are there?\")\n",
+    "task_data = TaskRequest(\n",
+    "    name=JobNames.CROW, query=\"How many species of birds are there?\"\n",
+    ")\n",
+    "\n",
+    "task_response = client.run_tasks_until_done(task_data)\n",
     "\n",
-    "job_id = client.create_job(job_data)\n",
-    "while client.get_job().status != \"success\":\n",
-    "    time.sleep(5)\n",
-    "print(f\"First job status: {client.get_job().status}\")\n",
-    "print(f\"First job answer: \\n{client.get_job().formatted_answer}\")"
+    "print(f\"First job status: {task_response.status}\")\n",
+    "print(f\"First job answer: \\n{task_response.formatted_answer}\")"
    ]
   },
   {
@@ -163,14 +158,14 @@
     "continued_job_data = {\n",
     "    \"name\": JobNames.CROW,\n",
     "    \"query\": \"From the previous answer, specifically,how many species of crows are there?\",\n",
-    "    \"runtime_config\": {\"continued_job_id\": job_id},\n",
+    "    \"runtime_config\": {\"continued_job_id\": task_response.task_id},\n",
     "}\n",
     "\n",
-    "continued_job_id = client.create_job(continued_job_data)\n",
-    "while client.get_job().status != \"success\":\n",
-    "    time.sleep(5)\n",
-    "print(f\"Continued job status: {client.get_job().status}\")\n",
-    "print(f\"Continued job answer: \\n{client.get_job().formatted_answer}\")"
+    "continued_task_response = client.run_tasks_until_done(continued_job_data)\n",
+    "\n",
+    "\n",
+    "print(f\"Continued job status: {continued_task_response.status}\")\n",
+    "print(f\"Continued job answer: \\n{continued_task_response.formatted_answer}\")"
    ]
   }
  ],

{futurehouse_client-0.3.16 → futurehouse_client-0.3.17.dev94}/futurehouse_client/clients/job_client.py

@@ -29,6 +29,7 @@ class JobNames(StrEnum):
     FALCON = "job-futurehouse-paperqa2-deep"
     OWL = "job-futurehouse-hasanyone"
     DUMMY = "job-futurehouse-dummy-env"
+    PHOENIX = "job-futurehouse-phoenix"
 
     @classmethod
     def from_stage(cls, job_name: str, stage: Stage | None = None) -> str: