langfun 0.1.2.dev202510160805__py3-none-any.whl → 0.1.2.dev202510180803__py3-none-any.whl

langfun/__init__.py

@@ -66,8 +66,8 @@ from langfun.core import agentic
 Action = agentic.Action
 Session = agentic.Session
 
+from langfun.core import mcp
 from langfun.core import memories
-
 from langfun.core import modalities
 
 Mime = modalities.Mime

langfun/core/__init__.py

@@ -40,9 +40,13 @@ from langfun.core.component import context
 as_context = context
 use_context = context
 
-# Invoke a callable object asynchronously.
+# Support for async IO.
 from langfun.core.async_support import invoke_async
 
+# Adaptors for async function/context manager to sync versions.
+from langfun.core.async_support import invoke_sync
+from langfun.core.async_support import sync_context_manager
+
 # Shortcut function for overriding components attributes, usually for
 # override settings.
 from langfun.core.component import use_settings

langfun/core/async_support.py

@@ -14,15 +14,85 @@
 """Utility for async IO in Langfun."""
 
 import asyncio
-from typing import Any, Callable
+import contextlib
+from typing import Any, Awaitable, Callable, Iterator
+import anyio
 import pyglove as pg
 
 
 async def invoke_async(
-    callable_object: Callable[..., Any], *args, **kwargs
+    sync_callable: Callable[..., Any], *args, **kwargs
 ) -> Any:
   """Invokes a callable asynchronously with `lf.context` manager enabled."""
   return await asyncio.to_thread(
       # Enable `lf.context` manager for async calls.
-      pg.with_contextual_override(callable_object), *args, **kwargs
+      pg.with_contextual_override(sync_callable), *args, **kwargs
   )
+
+
+def invoke_sync(
+    async_callable: Callable[..., Awaitable[Any]],
+    *args,
+    **kwargs
+) -> Any:
+  """Invokes a async callable synchronously."""
+  async def _invoke():
+    return await async_callable(*args, **kwargs)
+  invoke_fn = pg.with_contextual_override(_invoke)
+  blocking_portal = pg.utils.thread_local_get('__blocking_portal__', None)
+  if blocking_portal is None:
+    return anyio.run(invoke_fn)
+  return blocking_portal.call(invoke_fn)
+
+
+@contextlib.contextmanager
+def sync_context_manager(
+    async_context_manager: contextlib.AbstractAsyncContextManager[Any]
+) -> Iterator[Any]:
+  """Adapts an async context manager to a sync context manager.
+
+  sync_context_manager installs a blocking portal in current thread to run the
+  async context manager in a blocking way. It's useful for running async code in
+  sync context managers, e.g. `sync_context_manager` can be nested and share the
+  same event loop.
+
+  Example:
+
+    ```python
+    @contextlib.asynccontextmanager
+    async def foo(x):
+      try:
+        yield x
+      finally:
+        pass
+
+    with lf.sync_context_manager(foo(x)) as x
+      with lf.sync_context_manager(foo(y)) as y:
+        ...
+    ```
+
+  Args:
+    async_context_manager: The async context manager to adapt.
+
+  Yields:
+    The value yielded by the async context manager.
+  """
+  blocking_portal = pg.utils.thread_local_get('__blocking_portal__', None)
+  portal_exit_stack = None
+
+  try:
+    if blocking_portal is None:
+      portal_exit_stack = contextlib.ExitStack()
+      blocking_portal = portal_exit_stack.enter_context(
+          anyio.from_thread.start_blocking_portal()
+      )
+      pg.utils.thread_local_set('__blocking_portal__', blocking_portal)
+    context_manager = blocking_portal.wrap_async_context_manager(
+        async_context_manager
+    )
+    with context_manager as value:
+      yield value
+  finally:
+    if portal_exit_stack is not None:
+      portal_exit_stack.close()
+      pg.utils.thread_local_del('__blocking_portal__')

langfun/core/async_support_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import asyncio
+import contextlib
 import time
 import unittest
 
@@ -34,6 +35,28 @@ class AsyncSupportTest(unittest.TestCase):
     with pg.contextual_override(z=3):
       self.assertEqual(asyncio.run(r), 6)
 
+  def test_invoke_sync(self):
+    @contextlib.asynccontextmanager
+    async def bar(x):
+      try:
+        yield x
+      finally:
+        pass
+
+    async def foo(x, *, y):
+      time.sleep(2)
+      return x + y + pg.contextual_value('z', 0)
+
+    with pg.contextual_override(z=3):
+      with async_support.sync_context_manager(bar(1)) as x:
+        self.assertEqual(x, 1)
+        with async_support.sync_context_manager(bar(2)) as y:
+          self.assertEqual(y, 2)
+          self.assertEqual(async_support.invoke_sync(foo, 1, y=2), 6)
+
+    with pg.contextual_override(z=2):
+      self.assertEqual(async_support.invoke_sync(foo, 1, y=2), 5)
+
 
 if __name__ == '__main__':
   unittest.main()

langfun/core/concurrent_test.py

@@ -262,6 +262,7 @@ class ProgressControlTest(unittest.TestCase):
     with contextlib.redirect_stderr(string_io):
       ctrl.update(1)
       ctrl.refresh()
+      sys.stderr.flush()
     self.assertEqual(string_io.getvalue(), '')
     concurrent.progress_bar = 'tqdm'
 
@@ -274,6 +275,7 @@ class ProgressControlTest(unittest.TestCase):
       ctrl.set_status('bar')
       ctrl.update(10)
       ctrl.refresh()
+      sys.stderr.flush()
     self.assertEqual(
         string_io.getvalue(),
         '\x1b[1m\x1b[31mfoo\x1b[0m: \x1b[34m10% (10/100)\x1b[0m : bar\n'
@@ -288,6 +290,7 @@ class ProgressControlTest(unittest.TestCase):
       self.assertIsInstance(ctrl, concurrent._TqdmProgressControl)
       ctrl.update(10)
       ctrl.refresh()
+      sys.stderr.flush()
     self.assertIn('10/100', string_io.getvalue())
 
     tqdm = concurrent.tqdm
@@ -316,6 +319,7 @@ class ProgressBarTest(unittest.TestCase):
       for _ in concurrent.concurrent_execute(fun, range(5)):
         concurrent.ProgressBar.refresh()
       concurrent.ProgressBar.uninstall(bar_id)
+      sys.stderr.flush()
     output_str = string_io.getvalue()
     self.assertIn('100%', output_str)
     self.assertIn('5/5', output_str)
@@ -332,7 +336,7 @@ class ProgressBarTest(unittest.TestCase):
         concurrent.ProgressBar.update(bar_id, 0, status=1)
       concurrent.ProgressBar.uninstall(bar_id)
       sys.stderr.flush()
-      time.sleep(1)
+    time.sleep(1)
     self.assertIn('1/4', string_io.getvalue())
     # TODO(daiyip): Re-enable once flakiness is fixed.
     # self.assertIn('2/4', string_io.getvalue())
@@ -564,7 +568,8 @@ class ConcurrentMapTest(unittest.TestCase):
               fun, [1, 2, 3], timeout=1.5, max_workers=1, show_progress=True
           )
       ], key=lambda x: x[0])
-      string_io.flush()
+      sys.stderr.flush()
+
     self.assertEqual(   # pylint: disable=g-generic-assert
         output,
         [
@@ -592,6 +597,7 @@ class ConcurrentMapTest(unittest.TestCase):
               show_progress=bar_id, status_fn=lambda p: dict(x=1, y=1)
           )
       ], key=lambda x: x[0])
+      sys.stderr.flush()
 
     self.assertEqual(  # pylint: disable=g-generic-assert
         output,

langfun/core/eval/v2/progress_tracking_test.py

@@ -50,7 +50,7 @@ class TqdmProgressTrackerTest(unittest.TestCase):
     string_io = io.StringIO()
     with contextlib.redirect_stderr(string_io):
       _ = experiment.run(root_dir, 'new', plugins=[])
-    sys.stderr.flush()
+      sys.stderr.flush()
     self.assertIn('All: 100%', string_io.getvalue())
 
   def test_with_example_ids(self):
@@ -61,7 +61,7 @@ class TqdmProgressTrackerTest(unittest.TestCase):
     string_io = io.StringIO()
     with contextlib.redirect_stderr(string_io):
       _ = experiment.run(root_dir, 'new', example_ids=[1], plugins=[])
-    sys.stderr.flush()
+      sys.stderr.flush()
     self.assertIn('All: 100%', string_io.getvalue())
 
 

langfun/core/mcp/__init__.py

@@ -0,0 +1,10 @@
+"""Langfun MCP support."""
+
+# pylint: disable=g-importing-member
+
+from langfun.core.mcp.client import McpClient
+from langfun.core.mcp.session import McpSession
+from langfun.core.mcp.tool import McpTool
+from langfun.core.mcp.tool import McpToolInput
+
+# pylint: enable=g-importing-member

langfun/core/mcp/client.py

@@ -0,0 +1,122 @@
+# Copyright 2025 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""MCP client."""
+
+import abc
+from typing import Annotated, Type
+
+from langfun.core.mcp import session as mcp_session
+from langfun.core.mcp import tool as mcp_tool
+from mcp.server import fastmcp as fastmcp_lib
+import pyglove as pg
+
+
+class McpClient(pg.Object):
+  """Base class for MCP client.
+
+  Usage:
+
+  ```python
+
+  def tool_use():
+    client = lf.mcp.McpClient.from_command('<MCP_CMD>', ['<ARG1>', 'ARG2'])
+    tools = client.list_tools()
+    tool_cls = tools['<TOOL_NAME>']
+
+    # Print the python definition of the tool.
+    print(tool_cls.python_definition())
+
+    with client.session() as session:
+      return tool_cls(x=1, y=2)(session)
+
+  async def tool_use_async_version():
+    client = lf.mcp.McpClient.from_url('http://localhost:8000/mcp')
+    tools = client.list_tools()
+    tool_cls = tools['<TOOL_NAME>']
+
+    # Print the python definition of the tool.
+    print(tool_cls.python_definition())
+
+    async with client.session() as session:
+      return await tool_cls(x=1, y=2).acall(session)
+  ```
+  """
+
+  def _on_bound(self):
+    super()._on_bound()
+    self._tools = None
+
+  def list_tools(
+      self, refresh: bool = False
+  ) -> dict[str, Type[mcp_tool.McpTool]]:
+    """Lists all MCP tools."""
+    if self._tools is None or refresh:
+      with self.session() as session:
+        self._tools = session.list_tools()
+    return self._tools
+
+  @abc.abstractmethod
+  def session(self) -> mcp_session.McpSession:
+    """Creates a MCP session."""
+
+  @classmethod
+  def from_command(cls, command: str, args: list[str]) -> 'McpClient':
+    """Creates a MCP client from a tool."""
+    return _StdioMcpClient(command=command, args=args)
+
+  @classmethod
+  def from_url(
+      cls,
+      url: str,
+      headers: dict[str, str] | None = None
+  ) -> 'McpClient':
+    """Creates a MCP client from a URL."""
+    return _HttpMcpClient(url=url, headers=headers or {})
+
+  @classmethod
+  def from_fastmcp(cls, fastmcp: fastmcp_lib.FastMCP) -> 'McpClient':
+    """Creates a MCP client from a MCP server."""
+    return _InMemoryFastMcpClient(fastmcp=fastmcp)
+
+
+class _StdioMcpClient(McpClient):
+  """Stdio-based MCP client."""
+
+  command: Annotated[str, 'Command to execute.']
+  args: Annotated[list[str], 'Arguments to pass to the command.']
+
+  def session(self) -> mcp_session.McpSession:
+    """Creates a MCP session."""
+    return mcp_session.McpSession.from_command(self.command, self.args)
+
+
+class _HttpMcpClient(McpClient):
+  """Server-Sent Events (SSE)/Streamable HTTP-based MCP client."""
+
+  url: Annotated[str, 'URL to connect to.']
+  headers: Annotated[dict[str, str], 'Headers to send with the request.'] = {}
+
+  def session(self) -> mcp_session.McpSession:
+    """Creates a MCP session."""
+    return mcp_session.McpSession.from_url(self.url, self.headers)
+
+
+class _InMemoryFastMcpClient(McpClient):
+  """In-memory MCP client."""
+
+  fastmcp: Annotated[fastmcp_lib.FastMCP, 'MCP server to connect to.']
+
+  def session(self) -> mcp_session.McpSession:
+    """Creates a MCP session."""
+    return mcp_session.McpSession.from_fastmcp(self.fastmcp)

langfun/core/mcp/client_test.py

@@ -0,0 +1,98 @@
+# Copyright 2025 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for MCP client."""
+
+import inspect
+import unittest
+from langfun.core import async_support
+from langfun.core import mcp as lf_mcp
+from mcp.server import fastmcp as fastmcp_lib
+
+mcp = fastmcp_lib.FastMCP(host='0.0.0.0', port=1234)
+
+
+@mcp.tool()
+async def add(a: int, b: int) -> int:
+  """Adds two integers and returns their sum.
+
+  Args:
+    a: The first integer.
+    b: The second integer.
+
+  Returns:
+    The sum of the two integers.
+  """
+  return a + b
+
+
+class McpTest(unittest.TestCase):
+
+  def test_sync_usages(self):
+    client = lf_mcp.McpClient.from_fastmcp(mcp)
+    tools = client.list_tools()
+    self.assertEqual(len(tools), 1)
+    tool_cls = tools['add']
+    print(tool_cls.python_definition())
+    self.assertEqual(
+        tool_cls.python_definition(),
+        inspect.cleandoc(
+            '''
+            Add
+
+            ```python
+            class Add:
+              """Adds two integers and returns their sum.
+
+              Args:
+                a: The first integer.
+                b: The second integer.
+
+              Returns:
+                The sum of the two integers.
+              """
+              a: int
+              b: int
+            ```
+            '''
+        )
+    )
+    self.assertEqual(repr(tool_cls), '<tool-class \'Add\'>')
+    self.assertEqual(tool_cls.__name__, 'Add')
+    self.assertEqual(tool_cls.TOOL_NAME, 'add')
+    self.assertEqual(tool_cls(a=1, b=2).input_parameters(), {'a': 1, 'b': 2})
+    with client.session() as session:
+      self.assertEqual(
+          tool_cls(a=1, b=2)(session), 3
+      )
+
+  def test_async_usages(self):
+    async def _test():
+      client = lf_mcp.McpClient.from_fastmcp(mcp)
+      tools = client.list_tools()
+      self.assertEqual(len(tools), 1)
+      tool_cls = tools['add']
+      self.assertEqual(tool_cls.__name__, 'Add')
+      self.assertEqual(tool_cls.TOOL_NAME, 'add')
+      async with client.session() as session:
+        self.assertEqual(
+            (await tool_cls(a=1, b=2).acall(
+                session, returns_call_result=True))
+            .structuredContent['result'],
+            3
+        )
+    async_support.invoke_sync(_test)
+
+
+if __name__ == '__main__':
+  unittest.main()

langfun/core/mcp/session.py

@@ -0,0 +1,176 @@
+# Copyright 2025 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""MCP session."""
+
+import contextlib
+from typing import Any, Type
+import anyio
+from langfun.core import async_support
+from langfun.core.mcp import tool as mcp_tool
+import mcp
+from mcp.client import sse
+from mcp.client import streamable_http
+from mcp.server import fastmcp as fastmcp_lib
+from mcp.shared import memory
+
+
+class McpSession:
+  """Langfun's MCP session.
+
+  Compared to the standard mcp.ClientSession, Langfun's MCP session could be
+  used both synchronously and asynchronously.
+  """
+
+  def __init__(self, stream) -> None:
+    self._stream = stream
+    self._session = None
+    self._session_exit_stack = None
+    self._in_session = False
+
+    # For supporting sync context manager.
+    self._sync_context_manager_exit_stack = None
+
+  def __enter__(self) -> 'McpSession':
+    exit_stack = contextlib.ExitStack()
+    exit_stack.enter_context(async_support.sync_context_manager(self))
+    self._sync_context_manager_exit_stack = exit_stack
+    return self
+
+  def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+    assert self._sync_context_manager_exit_stack is not None
+    self._sync_context_manager_exit_stack.close()
+
+  async def __aenter__(self) -> 'McpSession':
+    assert self._session_exit_stack is None, 'Session cannot be re-entered.'
+
+    self._session_exit_stack = contextlib.AsyncExitStack()
+    stream_output = await self._session_exit_stack.enter_async_context(
+        self._stream
+    )
+    assert isinstance(stream_output, tuple) and len(stream_output) in (2, 3)
+    read, write = stream_output[:2]
+    self._session = mcp.ClientSession(read, write)
+    await self._session_exit_stack.enter_async_context(self._session)
+    await self._session.initialize()
+    return self
+
+  async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+    del exc_type, exc_val, exc_tb
+    if self._session is None:
+      return
+    assert self._session_exit_stack is not None
+    await self._session_exit_stack.aclose()
+    self._session = None
+
+  def list_tools(self) -> dict[str, Type[mcp_tool.McpTool]]:
+    """Lists all MCP tools synchronously."""
+    return async_support.invoke_sync(self.alist_tools)
+
+  async def alist_tools(self) -> dict[str, Type[mcp_tool.McpTool]]:
+    """Lists all MCP tools asynchronously."""
+    assert self._session is not None, 'MCP session is not entered.'
+    return {
+        t.name: mcp_tool.McpTool.make_class(t)
+        for t in (await self._session.list_tools()).tools
+    }
+
+  def call_tool(
+      self,
+      tool: mcp_tool.McpTool,
+      *,
+      returns_call_result: bool = False
+  ) -> Any:
+    """Calls a MCP tool synchronously."""
+    return async_support.invoke_sync(
+        self.acall_tool,
+        tool,
+        returns_call_result=returns_call_result
+    )
+
+  async def acall_tool(
+      self,
+      tool: mcp_tool.McpTool,
+      *,
+      returns_call_result: bool = False
+  ) -> Any:
+    """Calls a MCP tool asynchronously."""
+    assert self._session is not None, 'MCP session is not entered.'
+    tool_call_result = await self._session.call_tool(
+        tool.TOOL_NAME, tool.input_parameters()
+    )
+    if returns_call_result:
+      return tool_call_result
+    if (
+        tool_call_result.structuredContent
+        and 'result' in tool_call_result.structuredContent
+    ):
+      return tool_call_result.structuredContent['result']
+    return tool_call_result.content
+
+  @classmethod
+  def from_command(
+      cls,
+      command: str,
+      args: list[str] | None = None
+  ) -> 'McpSession':
+    """Creates a MCP session from a command."""
+    return cls(
+        mcp.stdio_client(
+            mcp.StdioServerParameters(command=command, args=args or [])
+        )
+    )
+
+  @classmethod
+  def from_url(
+      cls,
+      url: str,
+      headers: dict[str, str] | None = None
+  ) -> 'McpSession':
+    """Creates a MCP session from a URL."""
+    transport = url.removesuffix('/').split('/')[-1].lower()
+    if transport == 'mcp':
+      return cls(streamable_http.streamablehttp_client(url, headers or {}))
+    elif transport == 'sse':
+      return cls(sse.sse_client(url, headers or {}))
+    else:
+      raise ValueError(f'Unsupported transport: {transport}')
+
+  @classmethod
+  def from_fastmcp(
+      cls,
+      fastmcp: fastmcp_lib.FastMCP
+  ):
+    return cls(_client_streams_from_fastmcp(fastmcp))
+
+
+@contextlib.asynccontextmanager
+async def _client_streams_from_fastmcp(fastmcp: fastmcp_lib.FastMCP):
+  """Creates client streams from a MCP server."""
+  server = fastmcp._mcp_server  # pylint: disable=protected-access
+  async with memory.create_client_server_memory_streams(
+      ) as (client_streams, server_streams):
+    client_read, client_write = client_streams
+    server_read, server_write = server_streams
+
+    # Create a cancel scope for the server task
+    async with anyio.create_task_group() as tg:
+      tg.start_soon(
+          lambda: server.run(
+              server_read,
+              server_write,
+              server.create_initialization_options(),
+              raise_exceptions=True,
+          )
+      )
+      yield client_read, client_write

langfun/core/mcp/testing/simple_mcp_client.py

@@ -0,0 +1,33 @@
+# Copyright 2025 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""A simple MCP client for testing."""
+
+from absl import app
+from absl import flags
+from langfun.core import mcp
+
+
+_URL = flags.DEFINE_string(
+    'url',
+    'http://localhost:8000/mcp',
+    'URL of the MCP server.',
+)
+
+
+def main(_):
+  print(mcp.McpClient.from_url(url=_URL.value).list_tools())
+
+
+if __name__ == '__main__':
+  app.run(main)

langfun/core/mcp/testing/simple_mcp_server.py

@@ -0,0 +1,33 @@
+# Copyright 2025 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Simple MCP server for testing."""
+
+from absl import app as absl_app
+from mcp.server import fastmcp as fastmcp_lib
+
+mcp = fastmcp_lib.FastMCP(host='0.0.0.0', port=8000)
+
+
+@mcp.tool()
+async def add(a: int, b: int) -> int:
+  """Adds two integers and returns their sum."""
+  return a + b
+
+
+def main(_):
+  mcp.run(transport='streamable-http', mount_path='/mcp')
+
+
+if __name__ == '__main__':
+  absl_app.run(main)

langfun/core/mcp/tool.py

@@ -0,0 +1,125 @@
+# Copyright 2025 The Langfun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""MCP tool."""
+
+from typing import Annotated, Any, ClassVar
+
+from langfun.core.structured import schema as lf_schema
+import mcp
+import pyglove as pg
+
+
+class _McpToolMeta(pg.symbolic.ObjectMeta):
+
+  def __repr__(self) -> str:
+    return f'<tool-class \'{self.__name__}\'>'
+
+
+class McpTool(pg.Object, metaclass=_McpToolMeta):
+  """Base class for MCP tools."""
+
+  TOOL_NAME: Annotated[
+      ClassVar[str],
+      'Tool name.'
+  ]
+
+  @classmethod
+  def python_definition(cls, markdown: bool = True) -> str:
+    """Returns the Python definition of the tool."""
+    return lf_schema.Schema.from_value(cls).schema_str(
+        protocol='python', markdown=markdown
+    )
+
+  def __call__(
+      self,
+      session,
+      *,
+      returns_call_result: bool = False) -> Any:
+    """Calls a MCP tool synchronously.
+
+    Args:
+      session: A MCP session.
+      returns_call_result: If True, returns the call result. Otherwise returns
+        the result from structured content, or return content.
+
+    Returns:
+      The call result, or the result from structured content, or content.
+    """
+    return session.call_tool(
+        self,
+        returns_call_result=returns_call_result
+    )
+
+  async def acall(
+      self,
+      session,
+      *,
+      returns_call_result: bool = False) -> Any:
+    """Calls a MCP tool asynchronously."""
+    return await session.acall_tool(self, returns_call_result=returns_call_result)
+
+  def input_parameters(self) -> dict[str, Any]:
+    """Returns the input parameters of the tool."""
+    json = self.to_json()
+    def _transform(path: pg.KeyPath, x: Any) -> Any:
+      del path
+      if isinstance(x, dict):
+        x.pop(pg.JSONConvertible.TYPE_NAME_KEY, None)
+      return x
+    return pg.utils.transform(json, _transform)
+
+  @classmethod
+  def make_class(cls, tool_definition: mcp.Tool) -> type['McpTool']:
+    """Makes a MCP tool class from tool definition."""
+
+    class _McpTool(cls):
+      auto_schema = False
+
+    tool_cls = _McpTool
+    tool_cls.TOOL_NAME = tool_definition.name
+    tool_cls.__name__ = _snake_to_camel(tool_definition.name)
+    tool_cls.__doc__ = tool_definition.description
+    schema = pg.Schema.from_json_schema(
+        tool_definition.inputSchema, class_fn=McpToolInput.make_class
+    )
+    tool_cls.apply_schema(schema)
+    return tool_cls
+
+
+class _McpToolInputMeta(pg.symbolic.ObjectMeta):
+
+  def __repr__(self) -> str:
+    return f'<input-class \'{self.__name__}\'>'
+
+
+class McpToolInput(pg.Object, metaclass=_McpToolInputMeta):
+  """Base class for MCP tool inputs."""
+
+  @classmethod
+  def make_class(cls, name: str, schema: pg.Schema):
+    """Converts a schema to an input class."""
+
+    class _McpToolInput(cls):
+      pass
+
+    input_cls = _McpToolInput
+    input_cls.__name__ = _snake_to_camel(name)
+    input_cls.__doc__ = schema.description
+    input_cls.apply_schema(schema)
+    return input_cls
+
+
+def _snake_to_camel(name: str) -> str:
+  """Converts a snake_case name to a CamelCase name."""
+  return ''.join(x.capitalize() for x in name.split('_'))

{langfun-0.1.2.dev202510160805.dist-info → langfun-0.1.2.dev202510180803.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfun
-Version: 0.1.2.dev202510160805
+Version: 0.1.2.dev202510180803
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors
@@ -21,14 +21,18 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: anyio>=4.7.0
 Requires-Dist: jinja2>=3.1.2
+Requires-Dist: mcp>=1.17.0
 Requires-Dist: puremagic>=1.20
-Requires-Dist: pyglove>=0.4.5.dev202507140812
+Requires-Dist: pyglove>=0.5.0.dev202510170226
 Requires-Dist: requests>=2.31.0
 Provides-Extra: all
+Requires-Dist: anyio>=4.7.0; extra == "all"
 Requires-Dist: jinja2>=3.1.2; extra == "all"
+Requires-Dist: mcp>=1.17.0; extra == "all"
 Requires-Dist: puremagic>=1.20; extra == "all"
-Requires-Dist: pyglove>=0.4.5.dev202507140812; extra == "all"
+Requires-Dist: pyglove>=0.5.0.dev202510170226; extra == "all"
 Requires-Dist: requests>=2.31.0; extra == "all"
 Requires-Dist: google-auth>=2.16.0; extra == "all"
 Requires-Dist: pillow>=10.0.0; extra == "all"

{langfun-0.1.2.dev202510160805.dist-info → langfun-0.1.2.dev202510180803.dist-info}/RECORD

@@ -1,4 +1,4 @@
-langfun/__init__.py,sha256=krEJ1lyDkNARsacY6nBQpD3bQrFi4fifD-FwpwPbFPM,2635
+langfun/__init__.py,sha256=Kx-9_ODBpqqXb3cY5oSS-Sr-ZfuyM59W511ca9VYdRY,2663
 langfun/assistant/capabilities/gui/__init__.py,sha256=7-fWINsczHkEAT1hS4vVHnTW3JC_4PZW0E4HfjClOD8,1290
 langfun/assistant/capabilities/gui/bounding_box_parser.py,sha256=wJSEJvt2WFH0o9C3z9uW_vK0qRAJWbkgX5gBAJU7w6k,5832
 langfun/assistant/capabilities/gui/bounding_box_parser_test.py,sha256=9yBvt7fXT_BFVcOXUSm4K0mLdKRYwk2Y9zaCpYYgBnQ,10934
@@ -6,13 +6,13 @@ langfun/assistant/capabilities/gui/drawing.py,sha256=8wgol61P7HovLg5EaevRmDPXTFu
 langfun/assistant/capabilities/gui/drawing_test.py,sha256=d6LQ1ctG78YRi58UVBdndwyEqTC_ITdk191oA3tASxM,3421
 langfun/assistant/capabilities/gui/location.py,sha256=QYJlY5kUNEwiZFiPYRyFAO7bD2ez4jL5hYn1_AK1ulc,8643
 langfun/assistant/capabilities/gui/location_test.py,sha256=pQUOH1sKuAwjTTYKu615RUnecc_lNrddfvkyxf9297w,9051
-langfun/core/__init__.py,sha256=lZQNVBzQa5d6kQFHRwRg9zZqPaEC_-PwAV-73k4fzR4,4854
-langfun/core/async_support.py,sha256=Mzqze88WqWBRRcBVJEQ4H1jRgLwUP43acI0NZ7unZ7M,1022
-langfun/core/async_support_test.py,sha256=lZ4rZ-kWlc94lezTajOVo2OQbxWiHfF6KhKOfMGzELQ,1094
+langfun/core/__init__.py,sha256=GC4amBXybjSfYVrEQSLFb_KBhH75uD95GKkHNiJfwkY,5011
+langfun/core/async_support.py,sha256=WF4sflm0Q-UHJ8lPtlEo9hSwqXqm1kfaAYVPTyVP3n0,3062
+langfun/core/async_support_test.py,sha256=fMz1ulGrfUCuHp7RtYktuBwpbRN3kCBKnB4LFvaXSAA,1754
 langfun/core/component.py,sha256=g1kQM0bryYYYWVDrSMnHfc74wIBbpfe5_B3s-UIP5GE,3028
 langfun/core/component_test.py,sha256=0CxTgjAud3aj8wBauFhG2FHDqrxCTl4OI4gzQTad-40,9254
 langfun/core/concurrent.py,sha256=zY-pXqlGqss_GI20tM1gXvyW8QepVPUuFNmutcIdhbI,32760
-langfun/core/concurrent_test.py,sha256=zrkDid2oHSXJYGPhrQzA_6Af6oHAn9UrnYGZmN00ies,17693
+langfun/core/concurrent_test.py,sha256=KzXOlfR3i_-s_GKBLYrO5-ETCvHoFbFY2o9FEeOeXq4,17818
 langfun/core/console.py,sha256=cLQEf84aDxItA9fStJV22xJch0TqFLNf9hLqwJ0RHmU,2652
 langfun/core/console_test.py,sha256=pBOcuNMJdVELywvroptfcRtJMsegMm3wSlHAL2TdxVk,1679
 langfun/core/langfunc.py,sha256=G50YgoVZ0y1GFw2ev41MlOqr6qa8YakbvNC0h_E0PiA,11140
@@ -85,7 +85,7 @@ langfun/core/eval/v2/metrics_test.py,sha256=LibZXvWEJDVRY-Mza_bQT-SbmbXCHUnFhL7Z
 langfun/core/eval/v2/progress.py,sha256=azZgssQgNdv3IgjKEaQBuGI5ucFDNbdi02P4z_nQ8GE,10292
 langfun/core/eval/v2/progress_test.py,sha256=YU7VHzmy5knPZwj9vpBN3rQQH2tukj9eKHkuBCI62h8,2540
 langfun/core/eval/v2/progress_tracking.py,sha256=zNhNPGlnJnHELEfFpbTMCSXFn8d1IJ57OOYkfFaBFfM,6097
-langfun/core/eval/v2/progress_tracking_test.py,sha256=0d13LQyUKy1_bkscN0-vcBcQ36HNp89kgJ_N0jl2URM,2339
+langfun/core/eval/v2/progress_tracking_test.py,sha256=MC7hD-KfxqSIwKK_BN7oGx7HA8O3_fY-Y3cYYAhZzxE,2343
 langfun/core/eval/v2/reporting.py,sha256=yUIPCAMnp7InIzpv1DDWrcLO-75iiOUTpscj7smkfrA,8335
 langfun/core/eval/v2/reporting_test.py,sha256=CMK-vwho8cNRJwlbkCqm_v5fykE7Y3V6SaIOCY0CDyA,5671
 langfun/core/eval/v2/runners.py,sha256=bEniZDNu44AQgvqpwLsvBU4V_7WltAe-NPhYgIsLj1E,16848
@@ -121,6 +121,13 @@ langfun/core/llms/cache/__init__.py,sha256=QAo3InUMDM_YpteNnVCSejI4zOsnjSMWKJKzk
 langfun/core/llms/cache/base.py,sha256=rt3zwmyw0y9jsSGW-ZbV1vAfLxQ7_3AVk0l2EySlse4,3918
 langfun/core/llms/cache/in_memory.py,sha256=i58oiQL28RDsq37dwqgVpC2mBETJjIEFS20yHiV5MKU,5185
 langfun/core/llms/cache/in_memory_test.py,sha256=V2UPeu5co5vUwSkjekCH1B1iLm9qQKPaacvP6VW3GTg,10388
+langfun/core/mcp/__init__.py,sha256=cyVP_YTjOmbjhYg8BE7-RnE4Txt8wDukYC0anhHKpuo,286
+langfun/core/mcp/client.py,sha256=NBo4W2fdvYyywlUHynAbyh7LNohILccTkCiisj-UEEg,3642
+langfun/core/mcp/client_test.py,sha256=Vjbh7bXM8xXMMe_QOnFJ4rE0wITovAZbwk7Nu-cqf8g,2766
+langfun/core/mcp/session.py,sha256=dyuNXpLvM0TgLoUmWEwy5XCRf-IK7H_BbcNI2oFa_ek,5626
+langfun/core/mcp/tool.py,sha256=eap46OK4lrw5G5uCwPi4kUMNdaN1Bgy0cUi0bdLJI5Q,3607
+langfun/core/mcp/testing/simple_mcp_client.py,sha256=U5pUXa0SnB2-DdRI2vPhrdVUv14dX_OeS4mPLFpllMc,924
+langfun/core/mcp/testing/simple_mcp_server.py,sha256=dw4t6ERWMdmi6kDE38RU5oYu5MQbEX-GJ6CMxGcV-WE,994
 langfun/core/memories/__init__.py,sha256=HpghfZ-w1NQqzJXBx8Lz0daRhB2rcy2r9Xm491SBhC4,773
 langfun/core/memories/conversation_history.py,sha256=KR78PurXTSeqsRK9QG9xM7-f245rs20EvWO7Mm2n2Vw,1827
 langfun/core/memories/conversation_history_test.py,sha256=2kzAq2pUrbR01Z9jhxviIao52JK4JVjr5iGP8pwGxlU,2156
@@ -181,8 +188,8 @@ langfun/env/event_handlers/event_logger.py,sha256=3dbPjBe53dBgntYHlyLlj_77hVecPS
 langfun/env/event_handlers/event_logger_test.py,sha256=PGof3rPllNnyzs3Yp8kaOHLeTkVrzUgCJwlODTrVRKI,9111
 langfun/env/event_handlers/metric_writer.py,sha256=NgJKsd6xWOtEd0IjYi7coGEaqGYkkPcDjXN9CQ3vxPU,18043
 langfun/env/event_handlers/metric_writer_test.py,sha256=flRqK10wonhJk4idGD_8jjEjrfjgH0R-qcu-7Bj1G5s,5335
-langfun-0.1.2.dev202510160805.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-langfun-0.1.2.dev202510160805.dist-info/METADATA,sha256=au899IUDN58JgGfkb7QaynFP9i-qZruve58dFnL8b4g,7380
-langfun-0.1.2.dev202510160805.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-langfun-0.1.2.dev202510160805.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
-langfun-0.1.2.dev202510160805.dist-info/RECORD,,
+langfun-0.1.2.dev202510180803.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+langfun-0.1.2.dev202510180803.dist-info/METADATA,sha256=TKDSGp-jEDTFAdPMimMw8gFja3rQ3LQ4YHqko8-Ga7k,7522
+langfun-0.1.2.dev202510180803.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+langfun-0.1.2.dev202510180803.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
+langfun-0.1.2.dev202510180803.dist-info/RECORD,,