from typing import Dict, Listimport requestsimport osimport json
class ThreadsAPI():   def __init__(self):    self.url = "https://threads.com/api/public"    self.token = os.environ['THREADS_API_KEY']    self.headers = {'Authorization': 'Bearer ' + self.token, 'Content-Type': 'application/json'}    def _post(self, url: str, body: Dict[str, str]={}):    r = requests.post(self.url + url, json=body, headers=self.headers)    if r.status_code == 200:      try:        data = r.json()        return data      except requests.exceptions.RequestsJSONDecodeError:        print(f'Failed to parse response as JSON. Response content was: {r.text}')    else:      err_message = f'Request failed with status code {r.status_code}'      return {'ok': False, 'result': {'error': err_message, 'message': 'Check that you are using the correct id'}}
    return None
  def create_thread(self, channel_id: str, blocks: List[str]):    return self._post('/postThread', body={'channelID': channel_id, 'blocks': blocks})      def post_chat_message(self, chat_id: str, body: str):    return self._post('/postChatMessage', body={'chatID': chat_id, 'body': body})
  def post_comment(self, thread_id: str, parent_id: str = '', blocks: List[str] = []):    return self._post('/postComment', body={'threadID': thread_id, 'parentID': parent_id, 'blocks': blocks})

CREATE_THREAD_PROMPT = """  This tool is a wrapper around Thread's create_thread API, useful when you need to create a new thread.  The input is a dictionary with 2 fields: channel_id (string), and blocks (an array of strings).   The string blocks are formatted using Markdown.  For example, to create a new thread with 3 blocks in channel with channel_id=123, you would pass in the following  dictionary:  {{"channel_id": "123", "blocks": ["# Title", "## A header", "some content"]}}  """

from pydantic import Fieldfrom typing import Dictfrom langchain.tools.base import BaseToolfrom threads.api import ThreadsAPI
class ThreadsTool(BaseTool):    name = ""    description = ""    api: ThreadsAPI = Field(default_factory=ThreadsAPI)    mode: str        def _run(self, instructions) -> str:        """Use the Threads API tool to run an operation."""        if isinstance(instructions, dict):          instructions = str(instructions)        return self.api.run(self.mode, instructions)        async def _arun(self, query: str) -> str:        """Use the tool asynchronously."""        raise NotImplementedError("ThreadsAPI does not support async")

from typing import List
from langchain.agents.agent_toolkits.base import BaseToolkitfrom langchain.tools import BaseToolfrom threads.api import ThreadsAPIfrom threads.tool import ThreadsTool
class ThreadsToolkit(BaseToolkit):  """Threads Toolkit"""  tools: List[BaseTool] = []
  @classmethod  def from_threads_api(cls, threads_api: ThreadsAPI) -> "ThreadsToolkit":    actions = threads_api.list()    tools = [      ThreadsTool(        name=action["name"],        description=action["description"],        mode=action["mode"],        api=threads_api,      ) for action in actions    ]    return cls(tools=tools)
  def get_tools(self) -> List[BaseTool]:    """Get the tools in the toolkit."""    return self.tools

HUMANS = [{  'userID': '34470790405',  'name': 'Chat with Rami',  "description":  ("This tool is a chat with Rami, a software engineer in your organization."   "The input should be a question for Rami.")}, {  'userID': '34470789571',  'name':'Chat with Chris',  "description":  ("This tool is a chat with Chris, a designer in your organization."   "The input should be a question for Chris.")}]

from langchain.vectorstores import FAISSfrom langchain.docstore import InMemoryDocstorefrom langchain.embeddings import OpenAIEmbeddingsfrom langchain.chat_models import ChatOpenAIimport faiss
from auto_gpt.agent import AutoGPTfrom humans.toolkit import HumanToolkitfrom threads.toolkit import ThreadsToolkitfrom threads.api import ThreadsAPI
threads_api = ThreadsAPI()human_toolkit = HumanToolkit.from_threads_api(threads_api)threads_toolkit = ThreadsToolkit.from_threads_api(threads_api)
embeddings_model = OpenAIEmbeddings()embedding_size = 1536index = faiss.IndexFlatL2(embedding_size)vectorstore = FAISS(embeddings_model.embed_query, index, InMemoryDocstore({}), {})
agent = AutoGPT.from_llm_and_tools(    ai_name="Tailor",    ai_role="Assistant",    tools=human_toolkit.get_tools() + threads_toolkit.get_tools(),    llm=ChatOpenAI(temperature=0, model_name='gpt-4'),    memory=vectorstore.as_retriever())agent.chain.verbose = True

agent.run(["I am working on a project with Rami and Chris. Please find out the current status of our research project, and write a thread status report in channel_id=34470847918"])