When using the agent to call the tool, a RuntimeError occurs: generator ignored GeneratorExit

[wangyaoyong-wyy]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from langchain_chroma import Chroma
from langchain_community.chat_models import ChatTongyi
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain.agents import create_tool_calling_agent
from conf.configs import DASHSCOPE_API_KEY
from langchain_core.runnables.history import RunnableWithMessageHistory
from utils.createMysqlMessages import mysql_database_connection
from langchain_core.tools import tool, create_retriever_tool
from langchain_community.document_transformers import Html2TextTransformer
from langchain_community.document_loaders import RecursiveUrlLoader
import os
from langchain.agents import AgentExecutor


@tool
def get_word_length(word: str) -> int:
    """当输入不知道是什么意思的时候，调用该工具返回字符长度."""
    return len(word)


os.environ["DASHSCOPE_API_KEY"] = DASHSCOPE_API_KEY

url = "https://python.langchain.com/v0.2/docs/versions/v0_2/"
loader = RecursiveUrlLoader(url=url, max_depth=100)
docs = loader.load()
html2text = Html2TextTransformer()
docs_transformed = html2text.transform_documents(docs)
text_splitter = RecursiveCharacterTextSplitter(chunk_size=200, chunk_overlap=50)
docs = text_splitter.split_documents(docs_transformed)
db = Chroma.from_documents(docs, DashScopeEmbeddings(), persist_directory="D:\ollama")

# db = Chroma(persist_directory="D:\ollama", embedding_function=DashScopeEmbeddings())
retriever = db.as_retriever()
search_docs = create_retriever_tool(retriever, "langchain_search", "当需要搜索langchain相关知识的时候使用该工具")
tools = [get_word_length, search_docs]
chat = ChatTongyi(streaming=True)

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "你是一个乐于助人的AI助手.当你不知道如何回答的时候，优先考虑使用工具"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
        MessagesPlaceholder(variable_name="history", optional=True),
        ("human", "{input}"),
    ]
)
agent = create_tool_calling_agent(chat, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools,verbose=True, handle_parsing_errors=True)

# mysql_database_connection(session_id="a1").clear()

chain_with_history = RunnableWithMessageHistory(
    agent_executor,
    mysql_database_connection,
    input_messages_key="input",
    history_messages_key="history"
)
config = {"configurable": {"session_id": "a1"}}

print(chain_with_history.invoke({"input": "langchain 最新版本什么时候发布的"}, config=config))

Description

When I input questions for Q&A, The agent did not execute the output correctly after calling the tool

System Info

platform:windows11
python:3.11
langchian:0.2.1

[dosubot[bot]]

To resolve the RuntimeError: "generator ignored GeneratorExit" that occurs when using the agent to call the tool in your LangChain-based code, you need to ensure that your generator properly handles the GeneratorExit exception. This exception is raised when a generator or coroutine is closed, and it should be caught and handled appropriately.

In the provided code, the AgentExecutorIterator class has both synchronous and asynchronous iterator methods (__iter__ and __aiter__). You need to make sure that these methods handle the GeneratorExit exception.

Here is an example of how you can modify the __iter__ and __aiter__ methods to handle GeneratorExit:

def __iter__(self: "AgentExecutorIterator") -> Iterator[AddableDict]:
    logger.debug("Initialising AgentExecutorIterator")
    self.reset()
    callback_manager = CallbackManager.configure(
        self.callbacks,
        self.agent_executor.callbacks,
        self.agent_executor.verbose,
        self.tags,
        self.agent_executor.tags,
        self.metadata,
        self.agent_executor.metadata,
    )
    run_manager = callback_manager.on_chain_start(
        dumpd(self.agent_executor),
        self.inputs,
        self.run_id,
        name=self.run_name,
    )
    try:
        while self.agent_executor._should_continue(
            self.iterations, self.time_elapsed
        ):
            next_step_seq: NextStepOutput = []
            for chunk in self.agent_executor._iter_next_step(
                self.name_to_tool_map,
                self.color_mapping,
                self.inputs,
                self.intermediate_steps,
                run_manager,
            ):
                next_step_seq.append(chunk)
                if self.yield_actions:
                    if isinstance(chunk, AgentAction):
                        yield AddableDict(actions=[chunk], messages=chunk.messages)
                    elif isinstance(chunk, AgentStep):
                        yield AddableDict(steps=[chunk], messages=chunk.messages)
            next_step = self.agent_executor._consume_next_step(next_step_seq)
            self.update_iterations()
            output = self._process_next_step_output(next_step, run_manager)
            is_final = "intermediate_step" not in output
            if not self.yield_actions or is_final:
                yield output
            if is_final:
                return
    except GeneratorExit:
        logger.debug("GeneratorExit caught, cleaning up")
        run_manager.on_chain_error(GeneratorExit("Generator closed"))
        raise
    except BaseException as e:
        run_manager.on_chain_error(e)
        raise
    yield self._stop(run_manager)

async def __aiter__(self) -> AsyncIterator[AddableDict]:
    logger.debug("Initialising AgentExecutorIterator (async)")
    self.reset()
    callback_manager = AsyncCallbackManager.configure(
        self.callbacks,
        self.agent_executor.callbacks,
        self.agent_executor.verbose,
        self.tags,
        self.agent_executor.tags,
        self.metadata,
        self.agent_executor.metadata,
    )
    run_manager = await callback_manager.on_chain_start(
        dumpd(self.agent_executor),
        self.inputs,
        self.run_id,
        name=self.run_name,
    )
    try:
        async with asyncio_timeout(self.agent_executor.max_execution_time):
            while self.agent_executor._should_continue(
                self.iterations, self.time_elapsed
            ):
                next_step_seq: NextStepOutput = []
                async for chunk in self.agent_executor._aiter_next_step(
                    self.name_to_tool_map,
                    self.color_mapping,
                    self.inputs,
                    self.intermediate_steps,
                    run_manager,
                ):
                    next_step_seq.append(chunk)
                    if self.yield_actions:
                        if isinstance(chunk, AgentAction):
                            yield AddableDict(actions=[chunk], messages=chunk.messages)
                        elif isinstance(chunk, AgentStep):
                            yield AddableDict(steps=[chunk], messages=chunk.messages)
                next_step = self.agent_executor._consume_next_step(next_step_seq)
                self.update_iterations()
                output = await self._aprocess_next_step_output(next_step, run_manager)
                is_final = "intermediate_step" not in output
                if not self.yield_actions or is_final:
                    yield output
                if is_final:
                    return
    except GeneratorExit:
        logger.debug("GeneratorExit caught, cleaning up")
        await run_manager.on_chain_error(GeneratorExit("Generator closed"))
        raise
    except (TimeoutError, asyncio.TimeoutError):
        yield await self._astop(run_manager)
        return
    except BaseException as e:
        await run_manager.on_chain_error(e)
        raise
    yield await self._astop(run_manager)

By adding the except GeneratorExit block, you ensure that the generator properly handles the GeneratorExit exception, which should resolve the RuntimeError: "generator ignored GeneratorExit" issue ^[1][2].

To continue talking to Dosu, mention @dosu.

[RangerWolf]

@wangyaoyong-wyy
你解决了嘛？ 我用当前的最新版的langchain 0.2.6，model=qwen-max
遇到报错“KeyError: 'request'”

似乎这个报错很常见，类似的代码使用ChatGPT 就不会报错，不知道具体模型哪里的回复有问题了

[wangyaoyong-wyy]

@wangyaoyong-wyy 你解决了嘛？ 我用当前的最新版的langchain 0.2.6，model=qwen-max 遇到报错“KeyError: 'request'”

似乎这个报错很常见，类似的代码使用ChatGPT 就不会报错，不知道具体模型哪里的回复有问题了

搜一下Issues里面的，这个已经发布了，多追加一个参数，处理下工具格式