Multi-round-trip requests

कभी-कभी कोई tool एक round trip में पूरा नहीं हो पाता। उसे कुछ ऐसा चाहिए जो सिर्फ़ user के पास है: कोई चुनाव, कोई पुष्टि, कोई credential।

2026-07-28 से पहले server यह चीज़ वापस call करके लेता था: मूल request को संभालने के बीच में ही client की तरफ़ अपनी request खोलकर (कोई elicitation, कोई sampling call)। 2026-07-28 spec उस back-channel को बंद कर देता है।

इसके बजाय, server लौटाता है।

लौटाएँ, वापस call न करें

server tools/call का जवाब CallToolResult की जगह InputRequiredResult से देता है। इसके दो fields सारा काम करते हैं:

• input_requests: server को अभी और क्या चाहिए, एक dict के रूप में जिसकी keys server ने खुद चुनी हैं। हर value एक ElicitRequest, CreateMessageRequest, या ListRootsRequest है।
• request_state: एक opaque token। client retry पर इसे ज्यों का त्यों वापस भेजता है। इसे पढ़ने वाला सिर्फ़ server है।

client हर request पूरी करता है, फिर उसी tool को दोबारा call करता है, अपने जवाब input_responses में और token request_state में लेकर। अब server के पास वह है जो पहले नहीं था, और वह सामान्य CallToolResult लौटाता है।

पूरा protocol बस इतना ही है। हर चरण client से server की ओर जाने वाली साधारण request है। उल्टी दिशा में कभी कुछ नहीं बहता।

server की तरफ़

@mcp.tool() पर आप इसे शायद ही कभी हाथ से बनाते हैं: ऐसी dependency घोषित करें जो user से पूछती है (Elicit), client के LLM से sample लेती है (Sample), या उसके roots की सूची लेती है (ListRoots), और SDK आपके लिए InputRequiredResult लौटा देता है; वह रूप Dependencies page पर है। दोनों रूप आपस में नहीं मिलते: एक call के पास input_responses/request_state का एक ही channel होता है, इसलिए Resolve(...) parameters इस्तेमाल करने वाला tool अपनी body से InputRequiredResult भी नहीं लौटा सकता। घोषित InputRequiredResult return registration के समय ही अस्वीकार हो जाता है (InvalidSignature), और बिना घोषित वाला runtime पर call को fail कर देता है। हाथ से बनाने वाला रूप low-level Server है, जिसके on_call_tool handler को दोनों में से कोई भी result type लौटाने की अनुमति है:

from mcp.server import Server, ServerRequestContext
from mcp.types import (
    CallToolRequestParams,
    CallToolResult,
    ElicitRequest,
    ElicitRequestFormParams,
    ElicitResult,
    InputRequiredResult,
    ListToolsResult,
    PaginatedRequestParams,
    TextContent,
    Tool,
)

ASK_REGION = ElicitRequest(
    params=ElicitRequestFormParams(
        message="Which region should the database live in?",
        requested_schema={
            "type": "object",
            "properties": {"region": {"type": "string"}},
            "required": ["region"],
        },
    )
)


async def list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult:
    return ListToolsResult(
        tools=[
            Tool(
                name="provision",
                description="Provision a database. Asks which region to put it in.",
                input_schema={
                    "type": "object",
                    "properties": {"name": {"type": "string"}},
                    "required": ["name"],
                },
            )
        ]
    )


async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult | InputRequiredResult:
    answer = (params.input_responses or {}).get("region")
    if not isinstance(answer, ElicitResult) or answer.content is None:
        return InputRequiredResult(input_requests={"region": ASK_REGION}, request_state="provision-v1")
    name = (params.arguments or {})["name"]
    text = f"Provisioned {name!r} in {answer.content['region']}."
    return CallToolResult(content=[TextContent(type="text", text=text)])


server = Server("Provisioner", on_list_tools=list_tools, on_call_tool=call_tool)

• on_call_tool का type -> CallToolResult | InputRequiredResult है। दूसरा वाला लौटाना ही server की तरफ़ का पूरा API है।
• पहली call पर params.input_responses None है, इसलिए guard चलता है और handler जवाब देने के बजाय पूछता है।
• retry पर, client का भेजा ElicitResult उसी key ("region") के नीचे रखा मिलता है जो server ने input_requests में इस्तेमाल की थी।

उस file का बाकी सब कुछ (स्पष्ट input_schema, हाथ से बना CallToolResult) साधारण low-level Server है, जो Low-level Server में बताया गया है। यह page सिर्फ़ दूसरा return type जोड़ता है।

tools से आगे

tools/call में कुछ खास नहीं है: 2026-07-28 पर server prompts/get और resources/read का जवाब भी इसी तरह दे सकता है। MCPServer पर, @mcp.prompt() function — या @mcp.resource() template function — खुद InputRequiredResult लौटाता है और retry के जवाब context से पढ़ता है:

from mcp.server.mcpserver import Context, MCPServer
from mcp.server.mcpserver.prompts.base import UserMessage
from mcp.types import ElicitRequest, ElicitRequestFormParams, ElicitResult, InputRequiredResult

mcp = MCPServer("Briefing")

ASK_AUDIENCE = ElicitRequest(
    params=ElicitRequestFormParams(
        message="Who is the briefing for?",
        requested_schema={
            "type": "object",
            "properties": {"audience": {"type": "string"}},
            "required": ["audience"],
        },
    )
)


@mcp.prompt()
async def briefing(ctx: Context) -> list[UserMessage] | InputRequiredResult:
    """Draft a briefing tuned to its audience."""
    answer = (ctx.input_responses or {}).get("audience")
    if not isinstance(answer, ElicitResult) or answer.content is None:
        return InputRequiredResult(input_requests={"audience": ASK_AUDIENCE})
    return [UserMessage(f"Write a briefing for {answer.content['audience']}.")]

• पहला round InputRequiredResult लौटाता है। retry पर, ctx.input_responses में वही keys के नीचे जवाब होते हैं और function अपना साधारण result लौटाता है — यहाँ prompt messages, template resource के लिए resource content।
• आपका set किया request_state wire पार करने से पहले seal होता है और echo पर verify होता है, server पर बाकी सब की तरह; नीचे requestState की सुरक्षा बताता है कि seal आपको क्या देता है और keys कब configure करनी होती हैं।
• जब dependency वाला रूप फिट न बैठे, तो @mcp.tool() function भी इसी तरह सीधे result लौटा सकता है।
• static @mcp.resource() functions इसमें हिस्सा नहीं लेते: वे Context नहीं लेते, इसलिए retry कभी पढ़ ही नहीं सकते। सिर्फ़ template resources पूछ सकते हैं।
• नीचे दिए पीढ़ी के नियम बिना बदलाव लागू होते हैं: pre-2026 session पर InputRequiredResult लौटाना वही -32603 है जिसका ज़िक्र warning में है।

client की तरफ़

Client आपके लिए loop चलाता है।

वे callbacks register करें जो server माँग सकता है (elicitation_callback, sampling_callback, list_roots_callback) और tool call करें। जब InputRequiredResult आता है, Client input_requests की हर entry को मेल खाते callback के पास भेजता है, जवाबों और echo किए request_state के साथ retry करता है, और तब तक चलता रहता है जब तक CallToolResult वापस न आ जाए:

from mcp import Client
from mcp.client import ClientRequestContext
from mcp.types import ElicitRequestParams, ElicitResult


async def handle_elicitation(context: ClientRequestContext, params: ElicitRequestParams) -> ElicitResult:
    return ElicitResult(action="accept", content={"region": "eu-west-1"})


async def main() -> None:
    async with Client("http://127.0.0.1:8000/mcp", elicitation_callback=handle_elicitation) as client:
        result = await client.call_tool("provision", {"name": "orders"})
        print(result.content)

• वह elicitation_callback वही है जिस पर pre-2026 server का back-channel elicitation/create पहुँचता। sampling/createMessage के लिए sampling_callback और roots/list के लिए list_roots_callback पर भी यही बात लागू है: 2026-07-28 पर अलग से चलने वाले server->client RPC चले गए हैं, लेकिन हूबहू वही ElicitRequest / CreateMessageRequest / ListRootsRequest payloads input_requests के अंदर आते हैं और उन्हीं तीन callbacks तक पहुँचते हैं। callbacks का एक ही set दोनों पीढ़ियों को serve करता है।
• call_tool सादा CallToolResult लौटाता है। बीच के rounds caller को नहीं दिखते।
• get_prompt और read_resource भी यही loop चलाते हैं।

loop की सीमा है। Client(..., input_required_max_rounds=10) default cap है; जो server उससे आगे भी InputRequiredResult लौटाता रहे, वह call_tool से raise करवा देता है। अगर किसी round में सिर्फ़ request_state हो और कोई input_requests न हो, तो Client retry करने से पहले थोड़ी देर sleep करता है (50ms से दोगुना होते हुए 250ms की सीमा तक), ताकि जो server बस "अभी पूरा नहीं हुआ" कह रहा है उसे लगातार poll न किया जाए।

loop खुद चलाना

एक ही process वाले client के लिए auto-loop काफ़ी है। loop खुद तब संभालें जब:

• आपका client distributed है: जो process user को सवाल दिखाता है, वह वही process नहीं है जिसने call_tool call किया था, इसलिए retry कोई दूसरा worker भेजता है। request_state वह सहेजा जा सकने वाला token है जिसे आप अपने storage के ज़रिए उस सीमा के पार ले जाते हैं, और input_responses वह है जो दूसरी तरफ़ से उसके साथ वापस आता है।
• आप हर round को जाँचना चाहते हैं: input_requests की हर entry को log या audit करना, कुछ तरह की requests को मना करना, या चरणों के बीच अपना backoff लगाना।
• आपको round की गिनती के बजाय घड़ी के समय की सीमा चाहिए: input_required_max_rounds पर निर्भर रहने के बजाय अपने loop को anyio.fail_after(...) में लपेटें।

नीचे के session पर उतरें, जहाँ allow_input_required=True आपको सीधे union देता है:

from mcp import Client
from mcp.types import CallToolResult, ElicitRequest, ElicitResult, InputRequest, InputRequiredResult, InputResponse


def fulfil(request: InputRequest) -> InputResponse:
    if not isinstance(request, ElicitRequest):
        raise NotImplementedError(f"this client cannot answer a {request.method!r} request")
    return ElicitResult(action="accept", content={"region": "eu-west-1"})


async def provision(client: Client, name: str) -> CallToolResult:
    result = await client.session.call_tool("provision", {"name": name}, allow_input_required=True)
    while isinstance(result, InputRequiredResult):
        responses = {key: fulfil(request) for key, request in (result.input_requests or {}).items()}
        result = await client.session.call_tool(
            "provision",
            {"name": name},
            input_responses=responses,
            request_state=result.request_state,
            allow_input_required=True,
        )
    return result

• client.session.call_tool(..., allow_input_required=True) return type को CallToolResult | InputRequiredResult तक चौड़ा कर देता है। isinstance ही उसे वापस संकरा करता है।
• request_state अब आपके हाथ में है। चरणों के बीच इसे लिखकर रख लें तो बातचीत किसी नए process से फिर शुरू हो सकती है।
• input_requests की हर entry के लिए आप input_responses में उसी key के नीचे एक InputResponse रखते हैं। fulfil वह जगह है जहाँ आपका UI आता है; यह वाला जवाब hard-code करता है।
• हर चरण में वही tool name, वही arguments। retry मूल call को दोबारा पूरा करना है, कोई नया method नहीं।

requestState की सुरक्षा

ऊपर सब कुछ request_state को echo मानता है, और wire पर वह बस इतना ही है। लेकिन client इसे चरणों के बीच अपने पास रखता है (processes के पार इसे लिखकर रखना ही वह चीज़ है जिसकी पिछले section ने अनुमति दी), इसलिए जो वापस आता है वह client का दिया input है: उसमें बदलाव हो सकता है, वह expire हो सकता है, या किसी बिल्कुल अलग call से उठाया गया हो सकता है। spec की माँग है कि जब भी यह state authorization, resource access, या business logic पर असर डाल सकता हो, servers इस state की integrity सुरक्षित रखें और verification fail होने पर round को अस्वीकार करें।

MCPServer default रूप से इसकी सुरक्षा करता है। हर server बाहर जाने वाले requestState को seal करता है और हर echo को verify करता है — resolver state और हाथ से बना state, दोनों — process शुरू होने पर बनी key के तहत। आपको कुछ configure नहीं करना, plaintext लिखना है और plaintext पढ़ना है; wire पर सिर्फ़ एक opaque encrypted token जाता है।

default key process के साथ ही जीती-मरती है, और एक process से आगे deploy करने से पहले यही एक बात आपको पता होनी चाहिए:

from mcp.server.mcpserver import MCPServer, RequestStateSecurity

# Multi-instance or restart-surviving: one or more shared secret keys (>= 32 bytes each).
mcp = MCPServer("fleet", request_state_security=RequestStateSecurity(keys=[key]))

• default (बिना configuration) एक process के लिए ठीक है: stdio, या ठीक एक HTTP worker। जो retry किसी दूसरे worker पर, load balancer के पीछे किसी दूसरे instance पर, या restart के बाद उसी server पर पहुँचती है, वह ऐसी key के तहत seal हुई होती है जो उस process के पास नहीं है — client को नीचे वाला तय rejection मिलता है और उसे flow फिर से शुरू करना पड़ता है।
• keys=[...] तब ज़रूरी है जब भी retry किसी दूसरे instance तक पहुँच सकती हो (multi-worker uvicorn, load-balanced HTTP) या restarts के पार बचनी हो: हर instance वह verify करता है जो किसी भी sibling ने mint किया। वही मशीनरी, बनाई गई key की जगह आपका secret।
• अपनी crypto के लिए, जैसे कोई KMS या मौजूदा token service, keys की जगह RequestStateSecurity(codec=...) दें; नीचे अपनी crypto लाएँ contract बताता है।

seal में क्या होता है

default हो या configured, wire पर requestState एक encrypted, authenticated token है। आपका code इसे कभी नहीं देखता: handlers और resolvers plaintext लिखते हैं और plaintext पढ़ते हैं (ctx.request_state); SDK बाहर जाते समय seal करता है और अंदर आते समय verify करता है। integrity के अलावा, हर token इनसे बँधा होता है:

• एक समय सीमा। हर round नई expiry के साथ दोबारा seal करता है, इसलिए RequestStateSecurity(ttl=...) (default 600 seconds) हर round के सोचने के समय को बाँधता है, पूरे flow को नहीं।
• authenticated principal। जब request में ऐसा OAuth access token हो जिसे SDK ने validate किया, तो state उस token के client, issuer, और subject से बँध जाता है: एक user के लिए mint हुआ state दूसरे user के तहत fail होता है, भले ही दोनों users एक ही OAuth client साझा करते हों। जो verifier कोई subject नहीं देता, उसके साथ binding घटकर सिर्फ़ client identity तक रह जाती है, जो URL-आधारित client IDs में उस client software के हर user के बीच साझा होती है। जब auth SDK के बाहर खत्म होता है (आगे लगा proxy), या transport unauthenticated है, तो बाँधने के लिए कोई principal नहीं होता और यह जाँच निष्क्रिय रहती है, जब तक RequestStateSecurity(bind_principal=...) आपके अपने identity signal से कोई principal न दे। आपका token verifier जो भी components देता है, उन्हें लगातार एक जैसे देना चाहिए: जो verifier कुछ requests पर subject शामिल करे और दूसरों पर छोड़ दे, वह flow के बीच में principal बदल देता है, और चल रहे rounds अस्वीकार हो जाते हैं।
• मूल request। method, tool या prompt का नाम (या resource URI), और arguments का digest। किसी दूसरे tool, दूसरे arguments, या दूसरे method के विरुद्ध replay किया token fail होता है।
• पूछा गया ठीक वही सवाल। हर resolver जवाब उस rendered सवाल से जुड़ा होता है जो client को दिखाया गया था, उस round पर भी जब वह पहली बार आता है और तब भी जब दर्ज किया जवाब बाद में दोबारा इस्तेमाल होता है। बदले हुए शब्दों वाले message या बदले schema के साथ redeploy करें तो server बासी जवाब खाने के बजाय दोबारा पूछता है। यही जुड़ाव दूसरी दिशा में भी असर करता है: messages tool के arguments से बनाएँ, हर call के data से नहीं। timestamp या live rate से बना message हर round में अलग render होता है, इसलिए हर दर्ज जवाब बासी दिखता है और server तब तक दोबारा पूछता रहता है जब तक client की round सीमा call को खत्म न कर दे।

यह सब SDK का काम है, आपका नहीं, और अगर आप अपना codec लाते हैं तो codec का भी नहीं।

keys बदलना (rotation)

keys[0] नया state seal करती है; सूची की हर key verify करती है। zero-downtime rotation तीन चरणों में होता है, हर चरण अगले से पहले पूरी तरह roll out:

RequestStateSecurity(keys=[OLD, NEW])  # 1: every instance learns to verify NEW; OLD still mints
RequestStateSecurity(keys=[NEW, OLD])  # 2: NEW mints; in-flight OLD state keeps verifying
RequestStateSecurity(keys=[NEW])       # 3: one ttl after phase 2 is fully out, retire OLD

minter को कभी पहले promote न करें: ऐसी key के तहत mint करना जिसे कोई instance अभी verify नहीं कर सकता, rollout के बीच में चल रहे rounds गिरा देता है।

keys एक service तक सीमित हैं। sealed envelope में server का नाम audience claim के रूप में भी होता है, इसलिए किसी दूसरी service का mint किया token, जो संयोग से वही secret साझा करती हो, वैसे भी अस्वीकार हो जाता है। claim उतना ही विशिष्ट है जितना नाम, इसलिए जिस server को स्पष्ट policy दी गई हो उसका असली नाम होना चाहिए या उसे RequestStateSecurity(audience=...) set करना चाहिए — बिना नाम वाला construction पर ही raise करता है। audience= जान-बूझकर बनाई multi-service topologies के भी काम आता है जहाँ एक service को दूसरी का mint किया state स्वीकार करना हो। (बिना configuration वाला default इससे मुक्त है: उसकी key कभी process से बाहर नहीं जाती, इसलिए audience claim के पास जोड़ने को कुछ नहीं है।)

अपनी crypto लाएँ

RequestStateSecurity(codec=...) ऐसी कोई भी चीज़ लेता है जिसमें seal(bytes) -> str और unseal(str) -> bytes हों और जो हर उस token के लिए InvalidRequestState raise करे जो उसने mint नहीं किया। इसका classic रूप KMS के विरुद्ध envelope encryption है, जहाँ आप startup पर एक बार data key unwrap करते हैं और हर token की crypto local रखते हैं:

import os

from cryptography.exceptions import InvalidTag
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

from mcp.server import MCPServer
from mcp.server.mcpserver import InvalidRequestState, RequestStateSecurity

PREFIX = "kms1."  # format version; fed to GCM as associated data, so it is bound under the tag


def unwrap_data_key() -> bytes:
    """One KMS call at process start, kms.decrypt(CiphertextBlob=...); every token after that is local crypto."""
    return os.urandom(32)  # stand-in for the unwrapped 32-byte data key


class EnvelopeCodec:
    def __init__(self, data_key: bytes) -> None:
        self._aesgcm = AESGCM(data_key)

    def seal(self, payload: bytes) -> str:
        nonce = os.urandom(12)
        return PREFIX + (nonce + self._aesgcm.encrypt(nonce, payload, PREFIX.encode())).hex()

    def unseal(self, token: str) -> bytes:
        if not token.startswith(PREFIX):
            raise InvalidRequestState("unknown token format")
        body = token[len(PREFIX) :]
        try:
            raw = bytes.fromhex(body)
            if raw.hex() != body:  # only the exact string seal() produced verifies
                raise ValueError("non-canonical hex")
            return self._aesgcm.decrypt(raw[:12], raw[12:], PREFIX.encode())
        except (ValueError, InvalidTag) as exc:
            raise InvalidRequestState("token failed verification") from exc


mcp = MCPServer("Deployer", request_state_security=RequestStateSecurity(codec=EnvelopeCodec(unwrap_data_key())))

TTL, principal binding, और request binding codec का काम नहीं हैं: SDK हर codec के लिए इन्हें seal से पहले payload में डालता है और unseal के बाद दोबारा verify करता है। codec की ज़िम्मेदारियाँ सिर्फ़ integrity (छेड़छाड़ का मतलब raise) और, आदर्श रूप से, confidentiality हैं।

जब verification fail हो

हर inbound failure, चाहे छेड़छाड़ हुई हो, expire हुआ हो, किसी दूसरी request या principal के विरुद्ध replay हुआ हो, या ऐसी key के तहत seal हुआ हो जिसे यह server नहीं जानता, एक ही जवाब पाता है:

{"code": -32602, "message": "Invalid or expired requestState"}

हर कारण के लिए एक ही तय message, ताकि wire कभी न बताए कि कौन सी जाँच fail हुई; असली कारण server log में जाता है। tools/call, prompts/get, और resources/read पर हर inbound requestState जाँचा जाता है, वह भी जो ऐसे handler के लिए आए जो कभी state mint नहीं करता। व्यवहार में सबसे आम rejection कोई हमलावर नहीं है — यह default process-local key का restart से पहले वाली या किसी दूसरे instance की retry से टकराना है; client flow फिर शुरू करता है, और जब यह मायने रखता हो तो keys=[...] ही उपाय है।

हाथ से बना state

जो request_state आप खुद set करते हैं (tool, prompt, या resource-template function से InputRequiredResult लौटाकर), वह उसी मशीनरी से seal और verify होता है जिससे resolver state, code में एक भी बदलाव के बिना: plaintext लिखें, plaintext पढ़ें, और ऊपर की हर binding लागू होती है।

एक चीज़ जो SDK आपके लिए तय नहीं कर सकता, configured होने पर भी, वह है सवाल की पहचान: उसे नहीं पता कि आपके state में कोई जवाब आपके किस सवाल का है। अगर आप जवाब सवाल की key से store करते हैं, तो state में अपना सवाल-identifier शामिल करें और retry पर उसे जाँचें।

low-level Server बिना-batteries वाला स्तर है: MCPServer के विपरीत, जब तक आप boundary खुद न जोड़ें तब तक कुछ seal नहीं होता, और ऐसा करने तक आपका request_state ठीक वैसे ही wire पार करता है जैसा लिखा गया। एक line वाला opt-in Low-level Server में दिखाया गया है।

एक 2026-07-28 result

InputRequiredResult सिर्फ़ protocol version 2026-07-28 पर मौजूद है। in-memory Client(server) इसे आपके लिए negotiate करता है; wire पर, mode="auto" इसे खोज लेता है। connect करने के बाद client.protocol_version बताता है कि आपको क्या मिला।

सारांश

• 2026-07-28 पर जिस server को call के बीच input चाहिए, वह InputRequiredResult लौटाता है। वह client की तरफ़ कभी request नहीं खोलता।
• input_requests वह है जो उसे चाहिए। request_state एक opaque resume token है जिसे सिर्फ़ server पढ़ता है।
• Client आपके लिए retry loop चलाता है: elicitation_callback / sampling_callback / list_roots_callback register करें और call_tool सादा CallToolResult लौटाता है। input_required_max_rounds (default 10) इसकी सीमा है।
• rounds जाँचने या सहेजने के लिए client.session.call_tool(..., allow_input_required=True) इस्तेमाल करें और while isinstance(result, InputRequiredResult) loop खुद संभालें।
• @mcp.tool() पर, user से पूछने वाली dependency यह result आपके लिए बनाती है (Dependencies); low-level Server हाथ से बनाने वाला रूप है।
• prompts और resources भी हिस्सा लेते हैं: @mcp.prompt() या template @mcp.resource() function खुद InputRequiredResult लौटाता है और retry पर ctx.input_responses पढ़ता है।
• requestState client के दिए input के रूप में वापस आता है, इसलिए MCPServer इसे default रूप से seal करता है — resolver state और हाथ से बना state, दोनों — process-local key के तहत; multi-instance deployments RequestStateSecurity(keys=[...]) (या custom codec) देते हैं ताकि हर instance वह verify कर सके जो किसी sibling ने mint किया। seal हर token को एक समय सीमा, मूल request, और authenticated principal से बाँधता है, जब request में SDK का validate किया auth हो या bind_principal= आपका अपना identity signal दे (requestState की सुरक्षा)।

यही वह mechanism है जो server-initiated sampling और push-शैली के बाकी back-channel की जगह लेता है; Deprecated features देखें।