Issue with LangGraph modifying config in-place during execution. Config was not resumed correctly

[riderexin]

Hello,

I'm encountering an unexpected behavior when using LangGraph. The config object I pass in gets modified during the graph execution, which causes problems during interruption recovery.

---

Initial state before execution:

thread = {
    "configurable": {
        "thread_id": str(uuid.uuid4()),
        "search_api": "tavily",
        "planner_provider": "openai",
        "planner_model": "gpt-4o-mini",
        "planner_model_kwargs": {
            "api_key": os.environ["DMX_API_KEY"],
            "base_url": "https://www.dmxapi.cn/v1"
        },
        "writer_provider": "openai",
        "writer_model": "gpt-4o-mini",
        "writer_model_kwargs": {
            "api_key": os.environ["DMX_API_KEY"],
            "base_url": "https://www.dmxapi.cn/v1"
        },
        "max_search_depth": 2,
        "report_structure": REPORT_STRUCTURE,
    }
}

Code snippet executed:

topic = (
    "Overview of Model Context Protocol (MCP), an Anthropic‑backed open standard "
    "for integrating external context and tools with LLMs. "
    "Give an architectural overview for developers, tell me about interesting MCP servers, "
    "and compare to Google Agent2Agent (A2A) protocol."
)

async for event in graph.astream({"topic": topic}, thread, stream_mode="updates"):
    if '__interrupt__' in event:
        interrupt_value = event['__interrupt__'][0].value
        display(Markdown(interrupt_value))

Problem observed:
After running the above, the external thread dictionary gets modified unexpectedly:

• Both planner_model_kwargs and writer_model_kwargs fields are overwritten with empty dictionaries {}.
• This leads to errors when attempting to resume the graph because critical API keys are lost.

My questions:

• Why does LangGraph modify the passed-in config dictionary in-place?
• Is there internal logic in some node that clears or pops those model kwargs?
• Does the checkpoint/interruption mechanism fail to persist or restore the full config correctly?
• What is the recommended best practice to avoid this? For example, should I deep-copy config before passing, or manage model kwargs in state instead?

What I suspect:

• Python passes the dict by reference, so internal LangGraph logic modifies the same object.
• Some nodes might be clearing those fields during model init or checkpoint.
• The restore process might not properly merge the original config back.

I would appreciate advice from anyone experienced with LangGraph on whether this is a known issue or expected behavior. Thank you!

[riderexin]

Hi, I’ve figured out the issue I mentioned earlier.

It turns out the problem was caused by the init_chat_model() function. Specifically, this function mutates the model_kwargs dictionary in-place — likely by removing keys like api_key or base_url. As a result, when I passed the same planner_model_kwargs into the thread config, it was already empty because it had been modified earlier during model initialization.

[riderexin]

Additionally, I discovered a more subtle behavior related to the model_kwargs parameter in init_chat_model().

If I pass a dictionary that includes a key like "model": "gpt-4o-mini" inside model_kwargs, then the other fields such as api_key and base_url are preserved correctly. However, if I only include "model_provider": "openai" and omit the "model" key, then api_key and base_url are removed during initialization, and the dictionary ends up containing only a single key.

This suggests that init_chat_model() internally mutates the model_kwargs based on the presence or absence of specific keys — likely under the assumption that some defaults will be applied when "model" is not explicitly provided.

Just something to watch out for if you're dynamically building the configuration.

[riderexin]

Even if you put model_kwargs in state (such as
class State(TypedDict): messages: list[dict]; model_kwargs: dict,
as long as you pass this dictionary to init_chat_model(), it will still be modified in-place by the function (in-place mutation), clearing or deleting keys such as api_key, base_url, etc.

[riderexin]

    writer_model_kwargs = get_config_value(configurable.writer_model_kwargs or {})
    writer_model = init_chat_model(model=writer_model_name, model_provider=writer_provider, model_kwargs=writer_model_kwargs) 

still modified writer_model_kwargs and even the config

[riderexin]

AttributeError: 'mappingproxy' object has no attribute 'pop'
try to use mappingproxy dict. seem init_chat_model uses pop

[riderexin]

Since init_chat_model deletes the kwargs from the passed-in configuration, making a deep copy each time before passing it can solve part of the problem, but it's ineffective for concurrent nodes. As previously mentioned, the state-stored configurations also get deleted.

My final solution is to store the configurations in environment variables. Each time a new model is initialized, it retrieves the base_url and api_key from the environment variables, bypassing the model_kwargs parameter of init_chat_model. Alternatively, directly passing base_url and api_key is possible, but it requires extensive code changes and raises security concerns.