@@ -378,6 +378,98 @@ def _LiveClientContent_to_vertex(
   return to_object
 
 
+def _LiveClientContextUpdateTools_to_mldev(
+    api_client: BaseApiClient,
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['tools']) is not None:
+    setv(
+        to_object,
+        ['tools'],
+        [
+            _Tool_to_mldev(t.t_tool(api_client, item), to_object)
+            for item in t.t_tools(api_client, getv(from_object, ['tools']))
+        ],
+    )
+
+  return to_object
+
+
+def _LiveClientContextUpdateTools_to_vertex(
+    api_client: BaseApiClient,
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['tools']) is not None:
+    setv(
+        to_object,
+        ['tools'],
+        [
+            _Tool_to_vertex(t.t_tool(api_client, item), to_object)
+            for item in t.t_tools(api_client, getv(from_object, ['tools']))
+        ],
+    )
+
+  return to_object
+
+
+def _LiveClientContextUpdate_to_mldev(
+    api_client: BaseApiClient,
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['system_instruction']) is not None:
+    setv(
+        to_object,
+        ['systemInstruction'],
+        _Content_to_mldev(
+            t.t_content(getv(from_object, ['system_instruction'])), to_object
+        ),
+    )
+
+  if getv(from_object, ['tools']) is not None:
+    setv(
+        to_object,
+        ['tools'],
+        _LiveClientContextUpdateTools_to_mldev(
+            api_client, getv(from_object, ['tools']), to_object
+        ),
+    )
+
+  return to_object
+
+
+def _LiveClientContextUpdate_to_vertex(
+    api_client: BaseApiClient,
+    from_object: Union[dict[str, Any], object],
+    parent_object: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+  to_object: dict[str, Any] = {}
+  if getv(from_object, ['system_instruction']) is not None:
+    setv(
+        to_object,
+        ['systemInstruction'],
+        _Content_to_vertex(
+            t.t_content(getv(from_object, ['system_instruction'])), to_object
+        ),
+    )
+
+  if getv(from_object, ['tools']) is not None:
+    setv(
+        to_object,
+        ['tools'],
+        _LiveClientContextUpdateTools_to_vertex(
+            api_client, getv(from_object, ['tools']), to_object
+        ),
+    )
+
+  return to_object
+
+
 def _LiveClientMessage_to_mldev(
     api_client: BaseApiClient,
     from_object: Union[dict[str, Any], object],
@@ -408,6 +500,15 @@ def _LiveClientMessage_to_mldev(
   if getv(from_object, ['tool_response']) is not None:
     setv(to_object, ['toolResponse'], getv(from_object, ['tool_response']))
 
+  if getv(from_object, ['context_update']) is not None:
+    setv(
+        to_object,
+        ['contextUpdate'],
+        _LiveClientContextUpdate_to_mldev(
+            api_client, getv(from_object, ['context_update']), to_object
+        ),
+    )
+
   return to_object
 
 
@@ -447,6 +548,15 @@ def _LiveClientMessage_to_vertex(
   if getv(from_object, ['tool_response']) is not None:
     setv(to_object, ['toolResponse'], getv(from_object, ['tool_response']))
 
+  if getv(from_object, ['context_update']) is not None:
+    setv(
+        to_object,
+        ['contextUpdate'],
+        _LiveClientContextUpdate_to_vertex(
+            api_client, getv(from_object, ['context_update']), to_object
+        ),
+    )
+
   return to_object
 
 
 
@@ -114,6 +114,8 @@ def __init__(
     self.session_id = session_id
     self.setup_complete = setup_complete
 
+  # Note: `send` is deprecated. Do not add options here; use specific
+  # `send_*` methods instead.
   async def send(
       self,
       *,
@@ -445,6 +447,70 @@ async def send_tool_response(
 
     await self._ws.send(json.dumps({'tool_response': tool_response_dict}))
 
+  async def send_context_update(
+      self,
+      *,
+      system_instruction: Optional[types.ContentUnion] = None,
+      tools: Optional[types.ToolListUnion] = None,
+  ) -> None:
+    """Send in-session context updates to the model.
+
+    Updates to the context of the current session. Only fields that are set will
+    be updated. Updates are guaranteed to be processed *in order* with the rest of
+    the inputs.
+
+    Note:
+      `system_instruction` and `tools` are part of the model preamble, so updating
+      them invalidates the prefix cache. Update them only when strictly necessary
+      as it might have a performance impact on model generation.
+
+    Args:
+      system_instruction: Updated system instruction for the model.
+      tools: An updated list of tools the model may use to generate subsequent
+        responses. Pass an empty list `[]` to clear all tools.
+
+    Example:
+
+    .. code-block:: python
+
+      # Update instructions:
+      await session.send_context_update(
+          system_instruction="You are now a technical expert. Be concise."
+      )
+
+      # Update tools:
+      await session.send_context_update(tools=[my_func])
+
+      # Clear tools:
+      await session.send_context_update(tools=[])
+    """
+    if system_instruction is None and tools is None:
+      raise ValueError(
+          'At least one of `system_instruction` or `tools` must be set.'
+      )
+
+    tools_wrapper: Optional[types.LiveClientContextUpdateTools] = None
+    if tools is not None:
+      tools_wrapper = types.LiveClientContextUpdateTools(tools=tools)
+
+    update = types.LiveClientContextUpdate(
+        system_instruction=system_instruction,
+        tools=tools_wrapper,
+    )
+
+    client_message = types.LiveClientMessage(context_update=update)
+    if self._api_client.vertexai:
+      message_dict = live_converters._LiveClientMessage_to_vertex(
+          self._api_client, client_message
+      )
+    else:
+      message_dict = live_converters._LiveClientMessage_to_mldev(
+          self._api_client, client_message
+      )
+    message_dict = _common.convert_to_dict(message_dict)
+    message_dict = _common.encode_unserializable_types(message_dict)
+    await self._ws.send(json.dumps(message_dict))
+
   async def receive(self) -> AsyncIterator[types.LiveServerMessage]:
     """Receive model responses from the server.
 
@@ -890,7 +956,6 @@ def _parse_client_message(
               function_responses=function_response_list
           )
       )
-
     else:
       raise ValueError(
           f'Unsupported input type "{type(input)}" or input content "{input}"'
 
@@ -17,6 +17,7 @@
 """Tests for live.py."""
 
 import contextlib
+import inspect
 import json
 import os
 import ssl
@@ -2420,3 +2421,34 @@ async def test_bidi_setup_replicated_voice_config_with_consent(vertexai):
       replicated_sig['voice_consent_signature'].get('signature')
       == 'test_sig_abc123'
   )
+
+
+def test_live_client_message_fields_have_send_methods():
+  ignored_message_fields = {'setup'}
+  ignored_inner_fields = {
+      'realtime_input': {'media_chunks'},  # Exposed as `media`
+  }
+
+  for field_name, field_info in types.LiveClientMessage.model_fields.items():
+    if field_name in ignored_message_fields:
+      continue
+
+    method_name = f'send_{field_name}'
+    method = getattr(live.AsyncSession, method_name, None)
+    assert callable(method), (
+        f'AsyncSession is missing `{method_name}` for'
+        f' LiveClientMessage.{field_name}'
+    )
+
+    sig_params = set(inspect.signature(method).parameters.keys()) - {'self'}
+    inner_type = typing.get_args(field_info.annotation)[0]
+    expected_fields = set(
+        inner_type.model_fields.keys()
+    ) - ignored_inner_fields.get(field_name, set())
+
+    missing_params = expected_fields - sig_params
+    assert not missing_params, (
+        f'AsyncSession.{method_name} is missing parameters for'
+        f' {inner_type.__name__} fields: {sorted(missing_params)}'
+    )
+