langfun 0.1.2.dev202510260804__tar.gz → 0.1.2.dev202510280805__tar.gz

{langfun-0.1.2.dev202510260804 → langfun-0.1.2.dev202510280805}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfun
-Version: 0.1.2.dev202510260804
+Version: 0.1.2.dev202510280805
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors

{langfun-0.1.2.dev202510260804 → langfun-0.1.2.dev202510280805}/langfun/core/__init__.py

@@ -93,6 +93,7 @@ from langfun.core.message import UserMessage
 from langfun.core.message import AIMessage
 from langfun.core.message import SystemMessage
 from langfun.core.message import MemoryRecord
+from langfun.core.message import ToolMessage
 
 from langfun.core.message import MessageConverter
 

{langfun-0.1.2.dev202510260804 → langfun-0.1.2.dev202510280805}/langfun/core/data/conversion/anthropic.py

@@ -97,6 +97,8 @@ class AnthropicMessageConverter(lf.MessageConverter):
                 self._safe_read(source, 'media_type')
             ).from_bytes(base64.b64decode(self._safe_read(source, 'data')))
         )
+      elif t in ('server_tool_use', 'web_search_tool_result'):
+        continue
       else:
         raise ValueError(f'Unsupported content part: {part!r}.')
     message = message_cls.from_chunks(chunks)

{langfun-0.1.2.dev202510260804 → langfun-0.1.2.dev202510280805}/langfun/core/mcp/client_test.py

@@ -13,10 +13,10 @@
 # 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 langfun.core import message as lf_message
 from mcp.server import fastmcp as fastmcp_lib
 
 mcp = fastmcp_lib.FastMCP(host='0.0.0.0', port=1234)
@@ -42,38 +42,11 @@ class McpTest(unittest.TestCase):
     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
+          # Test `session.call_tool` method as `tool.__call__` is already tested
+          # in `tool_test.py`.
+          session.call_tool(tools['add'](a=1, b=2)), 3
       )
 
   def test_async_usages(self):
@@ -86,10 +59,10 @@ class McpTest(unittest.TestCase):
       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
+            # Test `session.acall_tool` method as `tool.acall` is already
+            # tested in `tool_test.py`.
+            await session.acall_tool(tool_cls(a=1, b=2), returns_message=True),
+            lf_message.ToolMessage(text='3', result=3)
         )
     async_support.invoke_sync(_test)
 

{langfun-0.1.2.dev202510260804 → langfun-0.1.2.dev202510280805}/langfun/core/mcp/session.py

@@ -89,34 +89,19 @@ class McpSession:
       self,
       tool: mcp_tool.McpTool,
       *,
-      returns_call_result: bool = False
+      returns_message: bool = False
   ) -> Any:
     """Calls a MCP tool synchronously."""
-    return async_support.invoke_sync(
-        self.acall_tool,
-        tool,
-        returns_call_result=returns_call_result
-    )
+    return tool(self, returns_message=returns_message)
 
   async def acall_tool(
       self,
       tool: mcp_tool.McpTool,
       *,
-      returns_call_result: bool = False
+      returns_message: 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
+    return await tool.acall(self, returns_message=returns_message)
 
   @classmethod
   def from_command(

langfun-0.1.2.dev202510280805/langfun/core/mcp/session_test.py

@@ -0,0 +1,54 @@
+# 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 session."""
+
+import unittest
+from unittest import mock
+
+from langfun.core.mcp import session as mcp_session
+import mcp
+from mcp.client import sse
+from mcp.client import streamable_http
+
+
+class McpSessionTest(unittest.TestCase):
+
+  @mock.patch.object(mcp, 'stdio_client', autospec=True)
+  def test_from_command(self, mock_stdio_client):
+    mcp_session.McpSession.from_command('my-command', ['--foo'])
+    mock_stdio_client.assert_called_once_with(
+        mcp.StdioServerParameters(command='my-command', args=['--foo'])
+    )
+
+  @mock.patch.object(streamable_http, 'streamablehttp_client', autospec=True)
+  def test_from_url_mcp(self, mock_streamablehttp_client):
+    mcp_session.McpSession.from_url(
+        'http://localhost/mcp', headers={'k': 'v'}
+    )
+    mock_streamablehttp_client.assert_called_once_with(
+        'http://localhost/mcp', {'k': 'v'}
+    )
+
+  @mock.patch.object(sse, 'sse_client', autospec=True)
+  def test_from_url_sse(self, mock_sse_client):
+    mcp_session.McpSession.from_url('http://localhost/sse', headers={'k': 'v'})
+    mock_sse_client.assert_called_once_with('http://localhost/sse', {'k': 'v'})
+
+  def test_from_url_unsupported(self):
+    with self.assertRaisesRegex(ValueError, 'Unsupported transport: foo'):
+      mcp_session.McpSession.from_url('http://localhost/foo')
+
+
+if __name__ == '__main__':
+  unittest.main()

{langfun-0.1.2.dev202510260804 → langfun-0.1.2.dev202510280805}/langfun/core/mcp/tool.py

@@ -13,8 +13,12 @@
 # limitations under the License.
 """MCP tool."""
 
+import base64
 from typing import Annotated, Any, ClassVar
 
+from langfun.core import async_support
+from langfun.core import message as lf_message
+from langfun.core import modalities as lf_modalities
 from langfun.core.structured import schema as lf_schema
 import mcp
 import pyglove as pg
@@ -41,37 +45,99 @@ class McpTool(pg.Object, metaclass=_McpToolMeta):
         protocol='python', markdown=markdown
     )
 
+  @classmethod
+  def result_to_message(
+      cls, result: mcp.types.CallToolResult
+  ) -> lf_message.ToolMessage:
+    """Converts a tool call result to a message.
+
+    This method allows users to convert an existing mcp.CallToolResult to a
+    Langfun ToolMessage.
+
+    Args:
+      result: The MCP tool call result.
+
+    Returns:
+      A ToolMessage object.
+    """
+    chunks = []
+    for item in result.content:
+      if isinstance(item, mcp.types.TextContent):
+        chunk = item.text
+      elif isinstance(item, mcp.types.ImageContent):
+        chunk = lf_modalities.Image.from_bytes(_base64_decode(item.data))
+      elif isinstance(item, mcp.types.AudioContent):
+        chunk = lf_modalities.Audio.from_bytes(_base64_decode(item.data))
+      else:
+        raise ValueError(f'Unsupported item type: {type(item)}')
+      chunks.append(chunk)
+    message = lf_message.ToolMessage.from_chunks(chunks)
+    if result.structuredContent:
+      message.metadata.update(result.structuredContent)
+    return message
+
   def __call__(
       self,
       session,
       *,
-      returns_call_result: bool = False) -> Any:
+      returns_message: 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_message: If True, always returns a ToolMessage. Otherwise,
+        return structured content (result) if available, otherwise return
+        ToolMessage if there is multi-modal content, otherwise return text.
 
     Returns:
       The call result, or the result from structured content, or content.
     """
-    return session.call_tool(
-        self,
-        returns_call_result=returns_call_result
+    return async_support.invoke_sync(
+        self.acall,
+        session,
+        returns_message=returns_message
     )
 
   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)
+      returns_message: bool = False
+  ) -> Any:
+    """Calls a MCP tool asynchronously.
+
+    Args:
+      session: McpSession or mcp.ClientSession.
+      returns_message: If True, always returns a ToolMessage. Otherwise,
+        return structured content (result) if available, otherwise return
+        ToolMessage if there is multi-modal content, otherwise return text.
+
+    Returns:
+      The call result, or the result from structured content, or content.
+    """
+    if not isinstance(session, mcp.ClientSession):
+      session = getattr(session, '_session', None)
+    assert session is not None, 'MCP session is not entered.'
+    tool_call_result = await session.call_tool(
+        self.TOOL_NAME, self.input_parameters()
+    )
+    message = self.result_to_message(tool_call_result)
+    if returns_message:
+      return message
+    if message.result:
+      return message.result
+    if message.referred_modalities:
+      return message
+    return message.text
 
   def input_parameters(self) -> dict[str, Any]:
     """Returns the input parameters of the tool."""
-    json = self.to_json()
+    # Optional fields are represented as fields with default values. Therefore,
+    # we need to remove the default values from the JSON representation of the
+    # tool.
+    json = self.to_json(hide_default_values=True)
+
+    # Remove the type name key from the JSON representation of the tool.
     def _transform(path: pg.KeyPath, x: Any) -> Any:
       del path
       if isinstance(x, dict):
@@ -123,3 +189,8 @@ class McpToolInput(pg.Object, metaclass=_McpToolInputMeta):
 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('_'))
+
+
+def _base64_decode(data: str) -> bytes:
+  """Decodes a base64 string."""
+  return base64.b64decode(data.encode('utf-8'))

langfun-0.1.2.dev202510280805/langfun/core/mcp/tool_test.py

@@ -0,0 +1,197 @@
+# 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 tool."""
+
+import base64
+import inspect
+import unittest
+
+from langfun.core import async_support
+from langfun.core import message as lf_message
+from langfun.core import modalities as lf_modalities
+from langfun.core.mcp import client as mcp_client
+from langfun.core.mcp import tool as mcp_tool
+import mcp
+from mcp.server import fastmcp as fastmcp_lib
+import pyglove as pg
+
+
+# MCP server setup for testing.
+_mcp_server = fastmcp_lib.FastMCP(host='0.0.0.0', port=1235)
+
+
+@_mcp_server.tool()
+async def add(a: int, b: int) -> int:
+  """Adds two integers."""
+  return a + b
+
+
+class McpToolTest(unittest.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.client = mcp_client.McpClient.from_fastmcp(_mcp_server)
+    self.tools = self.client.list_tools()
+
+  def test_snake_to_camel(self):
+    self.assertEqual(mcp_tool._snake_to_camel('foo_bar'), 'FooBar')
+    self.assertEqual(mcp_tool._snake_to_camel('foo'), 'Foo')
+
+  def test_base64_decode(self):
+    self.assertEqual(
+        mcp_tool._base64_decode(base64.b64encode(b'foo').decode('utf-8')),
+        b'foo'
+    )
+
+  def test_make_input_class(self):
+    schema = pg.Schema(
+        description='Foo input.',
+        fields=[
+            pg.typing.Field('x', pg.typing.Int(), 'Integer x.'),
+            pg.typing.Field('y', pg.typing.Str(), 'String y.'),
+        ],
+    )
+    input_cls = mcp_tool.McpToolInput.make_class('foo_input', schema)
+    self.assertTrue(issubclass(input_cls, mcp_tool.McpToolInput))
+    self.assertEqual(input_cls.__name__, 'FooInput')
+    self.assertEqual(input_cls.__doc__, 'Foo input.')
+    s = input_cls.__schema__
+    self.assertEqual(list(s.fields.keys()), ['x', 'y'])
+    self.assertEqual(repr(input_cls), "<input-class 'FooInput'>")
+    self.assertEqual(
+        repr(input_cls(x=1, y='abc')),
+        "FooInput(x=1, y='abc')",
+    )
+
+  def test_make_tool_class(self):
+    tool_def = mcp.Tool(
+        name='my_tool',
+        inputSchema={
+            'type': 'object',
+            'properties': {
+                'a': {'type': 'integer', 'description': 'Integer a.'},
+                'b': {'type': 'string', 'description': 'String b.'},
+            },
+            'required': ['a'],
+        },
+        description='My tool.',
+    )
+    tool_cls = mcp_tool.McpTool.make_class(tool_def)
+    self.assertTrue(issubclass(tool_cls, mcp_tool.McpTool))
+    self.assertEqual(tool_cls.__name__, 'MyTool')
+    self.assertEqual(tool_cls.TOOL_NAME, 'my_tool')
+    self.assertEqual(tool_cls.__doc__, 'My tool.')
+    s = tool_cls.__schema__
+    self.assertEqual(list(s.fields.keys()), ['a', 'b'])
+    self.assertEqual(repr(tool_cls), "<tool-class 'MyTool'>")
+    self.assertEqual(s.fields['a'].description, 'Integer a.')
+    self.assertEqual(s.fields['b'].description, 'String b.')
+
+    self.assertEqual(
+        tool_cls.python_definition(markdown=True),
+        inspect.cleandoc(
+            """
+            MyTool
+
+            ```python
+            class MyTool:
+              \"\"\"My tool.\"\"\"
+              # Integer a.
+              a: int
+              # String b.
+              b: str | None
+            ```
+            """
+        ),
+    )
+    self.assertEqual(
+        tool_cls.python_definition(markdown=False),
+        inspect.cleandoc(
+            """
+            MyTool
+
+            class MyTool:
+              \"\"\"My tool.\"\"\"
+              # Integer a.
+              a: int
+              # String b.
+              b: str | None
+            """
+        ),
+    )
+
+  def test_input_parameters(self):
+    tool_cls = self.tools['add']
+    self.assertEqual(tool_cls(a=1, b=2).input_parameters(), {'a': 1, 'b': 2})
+
+  def test_result_to_message(self):
+    img_data = base64.b64encode(b'image-data').decode('utf-8')
+    audio_data = base64.b64encode(b'audio-data').decode('utf-8')
+
+    tool_def = self.tools['add']
+    result = mcp.types.CallToolResult(
+        content=[
+            mcp.types.TextContent(type='text', text='hello'),
+            mcp.types.ImageContent(
+                type='image', data=img_data, mimeType='image/png'
+            ),
+            mcp.types.AudioContent(
+                type='audio', data=audio_data, mimeType='audio/wav'
+            ),
+        ],
+        structuredContent={'x': 1},
+    )
+    message = tool_def.result_to_message(result)
+    self.assertIsInstance(message, lf_message.ToolMessage)
+    self.assertIn('hello', message.text)
+    self.assertIn('<<[[image', message.text)
+    self.assertIn('<<[[audio', message.text)
+    self.assertEqual(message.metadata, {'x': 1})
+    modalities = message.modalities()
+    self.assertEqual(len(modalities), 2)
+    self.assertIsInstance(modalities[0], lf_modalities.Image)
+    self.assertEqual(modalities[0].to_bytes(), b'image-data')
+    self.assertIsInstance(modalities[1], lf_modalities.Audio)
+    self.assertEqual(modalities[1].to_bytes(), b'audio-data')
+
+  def test_sync_call(self):
+    add_tool_cls = self.tools['add']
+    with self.client.session() as session:
+      # Test returning structured content.
+      self.assertEqual(add_tool_cls(a=1, b=2)(session), 3)
+
+      # Test returning message.
+      self.assertEqual(
+          add_tool_cls(a=1, b=2)(session, returns_message=True),
+          lf_message.ToolMessage(text='3', result=3),
+      )
+
+  def test_async_call(self):
+    async def _test():
+      add_tool_cls = self.tools['add']
+      async with self.client.session() as session:
+        # Test returning structured content.
+        self.assertEqual(await add_tool_cls(a=1, b=2).acall(session), 3)
+
+        # Test returning message.
+        self.assertEqual(
+            await add_tool_cls(a=1, b=2).acall(session, returns_message=True),
+            lf_message.ToolMessage(text='3', result=3),
+        )
+
+    async_support.invoke_sync(_test)
+
+
+if __name__ == '__main__':
+  unittest.main()

{langfun-0.1.2.dev202510260804 → langfun-0.1.2.dev202510280805}/langfun/core/message.py

@@ -1070,3 +1070,10 @@ class MemoryRecord(Message):
   """Message used as a memory record."""
 
   sender = 'Memory'
+
+
+@pg.use_init_args(['text', 'sender', 'metadata'])
+class ToolMessage(Message):
+  """Message used as a tool call."""
+
+  sender = 'Tool'

{langfun-0.1.2.dev202510260804 → langfun-0.1.2.dev202510280805}/langfun.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langfun
-Version: 0.1.2.dev202510260804
+Version: 0.1.2.dev202510280805
 Summary: Langfun: Language as Functions.
 Home-page: https://github.com/google/langfun
 Author: Langfun Authors

{langfun-0.1.2.dev202510260804 → langfun-0.1.2.dev202510280805}/langfun.egg-info/SOURCES.txt

@@ -133,7 +133,9 @@ langfun/core/mcp/__init__.py
 langfun/core/mcp/client.py
 langfun/core/mcp/client_test.py
 langfun/core/mcp/session.py
+langfun/core/mcp/session_test.py
 langfun/core/mcp/tool.py
+langfun/core/mcp/tool_test.py
 langfun/core/mcp/testing/simple_mcp_client.py
 langfun/core/mcp/testing/simple_mcp_server.py
 langfun/core/memories/__init__.py