Get error of "TypeError: can only concatenate list (not "tuple") to list' when I was testing "Plan-and-Execute" example

[LeonMing30]

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

python:
config = {"recursion_limit": 50}
inputs = {"input": "what is the hometown of the 2024 Australia open winner?"}
async for event in app.astream(inputs, config=config):
    for k, v in event.items():
        if k != "__end__":
            print(v)

output:
{'plan': ['Find the name of the 2024 Australia Open winner', 'Look up the hometown of the 2024 Australia Open winner']}
{'past_steps': ('Find the name of the 2024 Australia Open winner', "The winner of the 2024 Australia Open is Jannik Sinner. He defeated Daniil Medvedev in a thrilling five-set final to claim the men's Australian Open title. Jannik Sinner became the first Italian man to win a Grand Slam since 1976.")}
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[23], line 3
      1 config = {"recursion_limit": 50}
      2 inputs = {"input": "what is the hometown of the 2024 Australia open winner?"}
----> 3 async for event in app.astream(inputs, config=config):
      4     for k, v in event.items():
      5         if k != "__end__":

File D:\Python\Lib\site-packages\langgraph\pregel\__init__.py:1307, in Pregel.astream(self, input, config, stream_mode, output_keys, input_keys, interrupt_before, interrupt_after, debug)
   1302     print_step_writes(
   1303         step, pending_writes, self.stream_channels_list
   1304     )
   1306 # apply writes to channels
-> 1307 _apply_writes(checkpoint, channels, pending_writes)
   1309 # yield current values
   1310 if "values" in stream_modes:

File D:\Python\Lib\site-packages\langgraph\pregel\__init__.py:1589, in _apply_writes(checkpoint, channels, pending_writes)
   1587 if chan in channels:
   1588     try:
-> 1589         channels[chan].update(vals)
   1590     except InvalidUpdateError as e:
   1591         raise InvalidUpdateError(
   1592             f"Invalid update for channel {chan} with values {vals}"
   1593         ) from e

File D:\Python\Lib\site-packages\langgraph\channels\binop.py:96, in BinaryOperatorAggregate.update(self, values)
     93     values = values[1:]
     95 for value in values:
---> 96     self.value = self.operator(self.value, value)

TypeError: can only concatenate list (not "tuple") to list

Description

I have copied the whole programme in https://langchain-ai.github.io/langgraph/tutorials/plan-and-execute/plan-and-execute/#create-the-graph.

System Info

langchain==0.2.3
langchain-community==0.2.4
langchain-core==0.2.5
langchain-openai==0.1.8
langchain-text-splitters==0.2.0
langchainhub==0.1.15
Note: you may need to restart the kernel to use updated packages.

[dosubot[bot]]

@LeonMing30 Hello there! I'm here to assist you with any bugs, questions, or contributions. Let's tackle this issue together.

To resolve the TypeError: can only concatenate list (not "tuple") to list error, you need to ensure that you are concatenating lists with lists, not tuples. This error typically occurs when you try to add a tuple to a list using the + operator.

In your example, it seems that the issue arises from the past_steps value being a tuple instead of a list. You need to convert the tuple to a list before concatenation.

Here's how you can modify your code to fix this issue:

config = {"recursion_limit": 50}
inputs = {"input": "what is the hometown of the 2024 Australia open winner?"}
async for event in app.astream(inputs, config=config):
    for k, v in event.items():
        if k != "__end__":
            # Ensure past_steps is a list before concatenation
            if k == "past_steps" and isinstance(v, tuple):
                v = list(v)
            print(v)

This modification ensures that past_steps is converted to a list if it is a tuple, preventing the TypeError when concatenating.

Additionally, you should check the _call and _acall methods in the PlanAndExecute class to ensure that any concatenation operations are correctly handling lists and tuples. Here is an example of how you might correct this error in those methods:

def _call(
    self,
    inputs: Dict[str, Any],
    run_manager: Optional[CallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
    plan = self.planner.plan(
        inputs,
        callbacks=run_manager.get_child() if run_manager else None,
    )
    if run_manager:
        run_manager.on_text(str(plan), verbose=self.verbose)
    for step in plan.steps:
        _new_inputs = {
            "previous_steps": self.step_container,
            "current_step": step,
            "objective": inputs[self.input_key],
        }
        new_inputs = {**_new_inputs, **inputs}
        response = self.executor.step(
            new_inputs,
            callbacks=run_manager.get_child() if run_manager else None,
        )
        if run_manager:
            run_manager.on_text(
                f"*****\n\nStep: {step.value}", verbose=self.verbose
            )
            run_manager.on_text(
                f"\n\nResponse: {response.response}", verbose=self.verbose
            )
        self.step_container.add_step(step, response)
    return {self.output_key: self.step_container.get_final_response()}

async def _acall(
    self,
    inputs: Dict[str, Any],
    run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
    plan = await self.planner.aplan(
        inputs,
        callbacks=run_manager.get_child() if run_manager else None,
    )
    if run_manager:
        await run_manager.on_text(str(plan), verbose=self.verbose)
    for step in plan.steps:
        _new_inputs = {
            "previous_steps": self.step_container,
            "current_step": step,
            "objective": inputs[self.input_key],
        }
        new_inputs = {**_new_inputs, **inputs}
        response = await self.executor.astep(
            new_inputs,
            callbacks=run_manager.get_child() if run_manager else None,
        )
        if run_manager:
            await run_manager.on_text(
                f"*****\n\nStep: {step.value}", verbose=self.verbose
            )
            await run_manager.on_text(
                f"\n\nResponse: {response.response}", verbose=self.verbose
            )
        self.step_container.add_step(step, response)
    return {self.output_key: self.step_container.get_final_response()}

Ensure that any concatenation in your "Plan-and-Execute" example follows this pattern ^[1].

To continue talking to Dosu, mention @dosu.

[Andor233]

@dosu doesn't work

[cristianohello]

do you solve it ?

[cristianohello]

me too???

[yuvaldream]

@cristianohello @LeonMing30 @Andor233

To solve it you need to change the returned "past_steps" from execute_step to a list, because it is declared as a list of tuples, not tuple.

In 'execute_step' function, change:

return {
"past_steps": (task, agent_response["messages"][-1].content),
}

To the following:

return {
"past_steps": [(task, agent_response["messages"][-1].content)],
}

[yuvaldream]

I also noticed that when the graph is completed the response was not written as it answered to user, but it was answered as the agent talk to itself.

So I have added the following line in the end of the replanner_prompt:

"Keep in mind that the user is unaware of your previous actions. If you choose to respond, make sure to address the user's question."