LangChain tools with injected arguments are not supported

[rohithbojja]

NotImplementedError: LangChain tools with injected arguments are not supported

from typing import Dict

@create_tool('add',description="Add two numbers")
def add(a: int, b: int,state: Annotated[Dict,InjectedState],tool_call_id: Annotated[str,InjectedToolCallId]) -> Command:
    """Add two numbers"""
    print("STATE",state)
    print("TOOL CALL ID",tool_call_id)
    if tool_call_id is None:
        tool_call_id = ""
    messages = state.get("messages", []) if state else []
    tool_message = ToolMessage(name="add",content=f"The sum of {a} and {b} is {a+b}",tool_call_id=tool_call_id)
    return Command(
        update={
            'messages': messages +[tool_message]
        }
        )

add_tool = to_fastmcp(add)
mcp = FastMCP("Add",tools=[add_tool])

import asyncio
server_task = asyncio.create_task(mcp.run_async(transport="sse",port=8762))

[eyurtsev]

What are you trying to achieve? I believe that the code raises a NotImplementedError with information saying that context args aren't supported. What do you expect InjectedState to do?

[rohithbojja]

What are you trying to achieve? I believe that the code raises a NotImplementedError with information saying that context args aren't supported. What do you expect InjectedState to do?

I want to retrieve state variables and update them via MCP Server

[premkiran-o7]

What are you trying to achieve? I believe that the code raises a NotImplementedError with information saying that context args aren't supported. What do you expect InjectedState to do?

I want to retrieve state variables and update them via MCP Server

As in if our tool does something and want to track that change in state of the graph?

[rohithbojja]

yes, like i want to validate_user using phone_number, but its should be fetched from State, it shouldnt ask user to provide phone_number and i should be able to update the phone_number or any customer data using that phone_number and update state with customer data,

Its working with InjectState,InjectedToolCallId returning a Command,

but how can this be achieved with mcp?
i want to serve my tools via MCP

[premkiran-o7]

yes, like i want to validate_user using phone_number, but its should be fetched from State, it shouldnt ask user to provide phone_number and i should be able to update the phone_number or any customer data using that phone_number and update state with customer data,

Its working with InjectState,InjectedToolCallId returning a Command,

but how can this be achieved with mcp? i want to serve my tools via MCP

I am not sure what InjectState, InjectedToolCallId is but how i dealt with my case was, if the tool message is having something specfic ( a key i deliberately introduced which would be present if there are changes to be done to variables in the state, I used to extract it from the content of ToolMessage and use my assistant node to update the state ).

But your use case needs phone_number to be passed right? why not just add it to a dynamic prompt and make the phone_number optional for the tool with None default value

[rohithbojja]

yes, like i want to validate_user using phone_number, but its should be fetched from State, it shouldnt ask user to provide phone_number and i should be able to update the phone_number or any customer data using that phone_number and update state with customer data,
Its working with InjectState,InjectedToolCallId returning a Command,
but how can this be achieved with mcp? i want to serve my tools via MCP

I am not sure what InjectState, InjectedToolCallId is but how i dealt with my case was, if the tool message is having something specfic ( a key i deliberately introduced which would be present if there are changes to be done to variables in the state, I used to extract it from the content of ToolMessage and use my assistant node to update the state ).

But your use case needs phone_number to be passed right? why not just add it to a dynamic prompt and make the phone_number optional for the tool with None default value

from langchain_core.messages import ToolMessage
from langgraph.graph import MessagesState
from typing import Literal,Annotated,Dict
from langgraph.types import Command
from langchain_core.tools import InjectedToolCallId, tool as create_tool
from langgraph.prebuilt import InjectedState, create_react_agent
from langchain.chat_models.base import init_chat_model
from langgraph.prebuilt.chat_agent_executor import AgentState

class CustomState(AgentState):
    bot_name: str
    bot_gender: Literal['male','female']
    

@create_tool('simple_add',description='Adds two Numbers')
def simple_add(a,b) -> Command:
    return f"The Result of {a} + {b} is {a+b}"

@create_tool('state_add',description='Adds two Numbers')
def state_add(a: int, b: int,state: Annotated[Dict,InjectedState],tool_call_id: Annotated[str,InjectedToolCallId]) -> Command:
    bot_name = state['bot_name']
    bot_gender = state['bot_gender']
    if bot_gender == 'male':
        return Command(update={
            "messages": [ToolMessage(
                content=f"Mr.{bot_name} said that the result of {a} + {b} is {a+b}",
                tool_call_id=tool_call_id,
                name='add_state'
                )]
        })
    elif bot_gender == 'female':
        return Command(update={
            "messages": [ToolMessage(
                content=f"Ms.{bot_name} said that the result of {a} + {b} is {a+b}",
                tool_call_id=tool_call_id,
                name='add_state'
                )]
        })
    else:
        return Command(update={
            "messages": [ToolMessage(
                content=f"{bot_name} said that the result of {a} + {b} is {a+b}",
                    tool_call_id=tool_call_id,
                    name='add_state'
                    )]
            })

agent = create_react_agent(
    name='agent',
    model=init_chat_model(
        'openai:gpt-4.1-nano'),
    tools=[simple_add,state_add],
    state_schema=CustomState
)

for chunk in agent.stream({
        'messages': {'role':'user','content':'Hi, add 5,7 using simple_add'},
        'bot_name': 'Viraj',
        'bot_gender': 'male'
    },stream_mode='messages'
):
    print(chunk[0].content,end='')

print("\n---------------------")
for chunk in agent.stream({
        'messages': {'role':'user','content':'Hi, add 5,8 using state_add'},
        'bot_name': 'Viraj',
        'bot_gender': 'male'
    },stream_mode='messages'
):
    print(chunk[0].content,end='')


The Result of 5 + 7 is 12The result of adding 5 and 7 is 12.
---------------------
Mr.Viraj said that the result of 5 + 8 is 13The result of adding 5 and 8 using `state_add` is 13.

Check this, like this i want to retireve state variables and use them and also can update them

Thats working with normal tools when i add it to agents,

but not working when i serve it using fastmcp.

[streamnsight]

We tried this too and had the same issue.
The MCP server serializes the function parameters, so it will pass a state parameter to the client to fill in, but the problem is the client has no way to know that this parameter is actually injected state.

Our solution has been:
use annotation on the MCP tool, that get passed to the client. On the client, monkey patch the ToolNode _get_state_args() function to look for our annotation and move the state variable to a state arg. That works fine, but feels hacky.

The main issue I see to make this a patch to this repo is that the StructuredTool object is build from the JSON schema when coming from the MCP server, but it is built from the function pydantic model when it is a local tool. The JSON schema doesn't include the function params annotations, and even if we pass an object class, the client doesn't know to convert it to an InjectedStateArg type.
There might be a pydantic way to do this, but I have not found it yet. pydantic is great to load json objects into existing object classes, but does not seem to handle building the object class dynamically easily, which is what we really need to create the 'local' tool function class to be used in the ToolNode.

[streamnsight]

I found a way to avoid having to monkey patch the _get_state_args function, but it is currently limited to base types

Draft PR here: #287
if someone wants to try and see if it works for your use case.

usage:
on the MCP server side. set the annotation on the tool:

@mcp.tool(annotation={"injected_state": "state"})
def your_tool(a: int, b: str, state: dict):
   return

where injected_state defines the name of the param to be injected, (here it is state) and needs to match the name of the tool function params for state.

[rohithbojja]

Thanks