ResponsesHostServer

The underlying :class:ResponsesAgentServerHost.

The hosted compiled state graph.

Start the server synchronously.

Once running, the host exposes POST /responses using the OpenAI Responses API create contract. See the OpenAI Responses API create docs <https://platform.openai.com/docs/api-reference/responses/create>_ for the full request and response schema. A minimal request is:

.. code-block:: json

{"input": "Hello!", "stream": false}

Common request fields include input, instructions, previous_response_id, conversation, and stream. Non-streaming requests return a Responses API response object whose output array contains items such as message, function_call, function_call_output, and mcp_approval_request. Streaming requests return text/event-stream with lifecycle events such as response.created, response.output_text.delta, and response.completed. Continue a conversation with previous_response_id or conversation.id.

Start the server asynchronously.

Exposes the same POST /responses contract as :meth:run, using the OpenAI Responses API create request and response schema. See the OpenAI Responses API create docs <https://platform.openai.com/docs/api-reference/responses/create>_ for the complete contract. A minimal request is:

.. code-block:: json

{"input": "Hello!", "stream": false}

Non-streaming requests return a Responses API response object whose output array contains items such as message, function_call, function_call_output, and mcp_approval_request. Streaming requests return text/event-stream with events such as response.created, response.output_text.delta, and response.completed. Continue a conversation with previous_response_id or conversation.id.

Translate the request into LangGraph input.

Default implementation builds a {"messages": [...]} payload from exactly one conversation-state source:

• responses_history mode prepends conversation history resolved from previous_response_id / conversation via the configured :class:ResponseProviderProtocol.
• langgraph_checkpoint mode passes only the current request input; prior state is restored by LangGraph through thread_id.

Override in a subclass to support custom-state graphs.

Build a resume :class:Command from the request's input items.

Default implementation scans the current request for either a function_call_output whose call_id matches one of the pending interrupts, or an mcp_approval_response whose approval_request_id matches. The former decodes its output JSON into a :class:Command; the latter resumes with the interrupt's own value when approve=True. Rejections (approve=False) are surfaced via :meth:detect_rejection instead. Override to plug in custom resume protocols.

Detect a client-issued rejection of a pending interrupt.

Default implementation scans the request for an mcp_approval_response item whose approval_request_id matches a pending interrupt and whose approve is False. When found, :meth:handle_create short-circuits the turn into response.failed(code="interrupt_rejected", …) instead of driving the graph.

Override to plug in custom rejection protocols (e.g. recognising a sentinel function_call_output payload as a rejection).

Build a LangGraph RunnableConfig for the request.

The logical thread is namespaced by the platform-provided user key. For previous_response_id chains, the root response is resolved through the Responses provider when possible. Checkpointed graphs additionally restore the exact (thread_id, checkpoint_id) saved for this user and conversation chain. The full :class:ResponseContext is exposed under configurable.response_context for transient execution facts such as recovery state.

Build a sync best-effort runnable config.

Prefer :meth:build_runnable_config in async request handling so previous_response_id chains can be resolved through the Responses provider.

Drive the graph and yield Responses API events.

Override this when wholesale customisation is needed. By default the method:

 1. emits ``response.created`` / ``response.in_progress`` and durably
     checkpoints handler admission,
        2. resolves the LangGraph thread and checks for pending
         ``interrupt()`` pauses on the checkpointed

thread and:

• if the request contains an mcp_approval_response with approve=false for a pending interrupt, emits response.failed(code="interrupt_rejected", …) and stops;
• otherwise tries to resume from a matching function_call_output (rich) or mcp_approval_response{approve:true} (echo the interrupt value back),

3. drives the graph via :meth:CompiledStateGraph.astream or :meth:CompiledStateGraph.ainvoke depending on request.stream,
4. emits the resulting output items, surfacing any new pending interrupts as a pair of function_call + mcp_approval_request items both keyed by the LangGraph interrupt id, and
5. emits response.completed (or response.failed / response.cancelled on error).