langfun 0.1.2.dev202507250804__py3-none-any.whl → 0.1.2.dev202507260804__py3-none-any.whl

langfun/core/__init__.py

@@ -40,6 +40,9 @@ from langfun.core.component import context
 as_context = context
 use_context = context
 
+# Invoke a callable object asynchronously.
+from langfun.core.async_support import invoke_async
+
 # Shortcut function for overriding components attributes, usually for
 # override settings.
 from langfun.core.component import use_settings

langfun/core/agentic/action.py

@@ -199,6 +199,24 @@ class Action(pg.Object):
     """Returns last invocation. None if the action is not executed."""
     return self._invocation
 
+  async def acall(
+      self,
+      session: Optional['Session'] = None,
+      *,
+      show_progress: bool = True,
+      verbose: bool = False,
+      **kwargs
+  ) -> Any:
+    """Async version of `__call__`."""
+    # TODO(daiyip): implement native async calling.
+    return await lf.invoke_async(
+        self.__call__,
+        session,
+        show_progress=show_progress,
+        verbose=verbose,
+        **kwargs
+    )
+
   def __call__(
       self,
       session: Optional['Session'] = None,

langfun/core/agentic/action_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Tests for base action."""
 
+import asyncio
 import unittest
 
 import langfun.core as lf
@@ -32,7 +33,7 @@ class Bar(action_lib.Action):
     session.add_metadata(note='bar')
     if self.simulate_action_error:
       raise ValueError('Bar error')
-    return 2
+    return 2 + pg.contextual_value('baz', 0)
 
 
 class Foo(action_lib.Action):
@@ -237,6 +238,12 @@ class SessionTest(unittest.TestCase):
     json_str = session.to_json_str(save_ref_value=True)
     self.assertIsInstance(pg.from_json_str(json_str), action_lib.Session)
 
+  def test_acall(self):
+    bar = Bar()
+    with lf.context(baz=1):
+      r = bar.acall(lm=fake.StaticResponse('lm response'))
+      self.assertEqual(asyncio.run(r), 3)
+
   def test_failed_action(self):
     lm = fake.StaticResponse('lm response')
     foo = Foo(1, simulate_action_error=True)

langfun/core/async_support.py

@@ -0,0 +1,28 @@
+# 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.
+"""Utility for async IO in Langfun."""
+
+import asyncio
+from typing import Any, Callable
+import pyglove as pg
+
+
+async def invoke_async(
+    callable_object: 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
+  )

langfun/core/async_support_test.py

@@ -0,0 +1,39 @@
+# 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.
+
+import asyncio
+import time
+import unittest
+
+from langfun.core import async_support
+import pyglove as pg
+
+
+class AsyncSupportTest(unittest.TestCase):
+
+  def test_invoke_async(self):
+
+    def foo(x, *, y):
+      time.sleep(2)
+      return x + y + pg.contextual_value('z', 0)
+
+    t = time.time()
+    r = async_support.invoke_async(foo, 1, y=2)
+    self.assertLess(time.time() - t, 1)
+    with pg.contextual_override(z=3):
+      self.assertEqual(asyncio.run(r), 6)
+
+
+if __name__ == '__main__':
+  unittest.main()

langfun/core/language_model.py

@@ -24,6 +24,7 @@ import re
 import threading
 import time
 from typing import Annotated, Any, Callable, ClassVar, Iterator, Literal, Optional, Sequence, Tuple, Type, Union, final
+from langfun.core import async_support
 from langfun.core import component
 from langfun.core import concurrent
 from langfun.core import console
@@ -922,6 +923,59 @@ class LanguageModel(component.Component):
   # Language model operations.
   #
 
+  async def asample(
+      self,
+      prompts: list[str | message_lib.Message],
+      *,
+      cache_seed: int = 0,
+      **kwargs,
+  ) -> message_lib.Message:
+    """Async version of sample."""
+    # TODO(daiyip): implement native async sampling.
+    return await async_support.invoke_async(
+        self.sample, prompts, cache_seed=cache_seed, **kwargs
+    )
+
+  async def acall(
+      self,
+      prompt: str | message_lib.Message,
+      *,
+      cache_seed: int = 0,
+      **kwargs
+  ) -> message_lib.Message:
+    """Async version of __call__."""
+    # TODO(daiyip): implement native async calling.
+    return await async_support.invoke_async(
+        self.__call__,
+        prompt,
+        cache_seed=cache_seed,
+        **kwargs
+    )
+
+  async def ascore(
+      self,
+      prompt: str | message_lib.Message | list[message_lib.Message],
+      completions: list[str | message_lib.Message],
+      **kwargs,
+  ) -> float:
+    """Async version of score."""
+    # TODO(daiyip): implement native async scoring.
+    return await async_support.invoke_async(
+        self.score,
+        prompt,
+        completions=completions,
+        **kwargs
+    )
+
+  async def atokenize(
+      self,
+      prompt: str | message_lib.Message,
+      **kwargs
+  ) -> list[int]:
+    """Async version of tokenize."""
+    # TODO(daiyip): implement native async tokenization.
+    return await async_support.invoke_async(self.tokenize, prompt, **kwargs)
+
   def sample(
       self,
       prompts: list[str | message_lib.Message],

langfun/core/language_model_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Tests for language model."""
 
+import asyncio
 import contextlib
 import io
 import unittest
@@ -436,6 +437,14 @@ class LanguageModelTest(unittest.TestCase):
         ]
     )
 
+  def test_sample_async(self):
+    lm = MockModel(top_k=1)
+    response = asyncio.run(lm.asample(['foo', 'bar']))
+    self.assertIsInstance(response, list)
+    self.assertEqual(len(response), 2)
+    self.assertIsInstance(response[0], lm_lib.LMSamplingResult)
+    self.assertIsInstance(response[1], lm_lib.LMSamplingResult)
+
   def test_call(self):
     lm = MockModel(sampling_options=lm_lib.LMSamplingOptions(top_k=1))
     response = lm(prompt='foo')
@@ -453,6 +462,11 @@ class LanguageModelTest(unittest.TestCase):
     # Test override individual flags within sampling_options.
     self.assertEqual(lm('foo', top_k=2), 'foo' * 2)
 
+  def test_acall(self):
+    lm = MockModel(sampling_options=lm_lib.LMSamplingOptions(top_k=1))
+    response = asyncio.run(lm.acall(prompt='foo'))
+    self.assertEqual(response.text, 'foo')
+
   def test_using_cache(self):
     cache = in_memory.InMemory()
     lm = MockModel(cache=cache, top_k=1)
@@ -765,6 +779,21 @@ class LanguageModelTest(unittest.TestCase):
       if debug_mode & lm_lib.LMDebugMode.PROMPT:
         self.assertIn('[0] MODALITY OBJECTS SENT TO LM', debug_info)
 
+  def test_ascore(self):
+    lm = MockScoringModel()
+    self.assertEqual(
+        asyncio.run(
+            lm.ascore(
+                message_lib.UserMessage('hi'),
+                ['1', '2']
+            )
+        ),
+        [
+            lm_lib.LMScoringResult(score=-0.0),
+            lm_lib.LMScoringResult(score=-1.0),
+        ],
+    )
+
   def test_score_with_unmatched_prompt_and_completions(self):
     with self.assertRaises(ValueError):
       MockScoringModel().score(['hi',], ['1', '2', '3'])
@@ -828,6 +857,17 @@ class LanguageModelTest(unittest.TestCase):
       if debug_mode & lm_lib.LMDebugMode.PROMPT:
         self.assertIn('[0] MODALITY OBJECTS SENT TO LM', debug_info)
 
+  def test_atokenize(self):
+    lm = MockTokenizeModel()
+    self.assertEqual(
+        asyncio.run(
+            lm.atokenize(
+                message_lib.UserMessage('hi')
+            )
+        ),
+        [('hi', 0)],
+    )
+
   def test_tokenize_with_unsupported_model(self):
     with self.assertRaises(NotImplementedError):
       MockModel().tokenize('hi')

langfun/core/structured/__init__.py

@@ -51,13 +51,16 @@ from langfun.core.structured.mapping import MappingError
 from langfun.core.structured.mapping import MappingExample
 
 from langfun.core.structured.parsing import parse
+from langfun.core.structured.parsing import aparse
 from langfun.core.structured.parsing import call
+from langfun.core.structured.parsing import acall
 
 from langfun.core.structured.querying import track_queries
 from langfun.core.structured.querying import QueryInvocation
 
 from langfun.core.structured.querying import LfQuery
 from langfun.core.structured.querying import query
+from langfun.core.structured.querying import aquery
 from langfun.core.structured.querying import query_and_reduce
 from langfun.core.structured.querying import query_protocol
 
@@ -67,10 +70,14 @@ from langfun.core.structured.querying import query_reward
 
 from langfun.core.structured.description import describe
 from langfun.core.structured.completion import complete
+from langfun.core.structured.completion import acomplete
 
 from langfun.core.structured.scoring import score
+from langfun.core.structured.scoring import ascore
 
 from langfun.core.structured.tokenization import tokenize
+from langfun.core.structured.tokenization import atokenize
+
 
 # Expose default examples for structured operations so users could refer to
 # them.

langfun/core/structured/completion.py

@@ -251,3 +251,31 @@ def complete(
 
   output = t(lm=lm, cache_seed=cache_seed, autofix_lm=autofix_lm or lm)
   return output if returns_message else output.result
+
+
+async def acomplete(
+    input_value: pg.Symbolic,
+    default: Any = lf.RAISE_IF_HAS_ERROR,
+    *,
+    lm: lf.LanguageModel | None = None,
+    examples: list[mapping.MappingExample] | None = None,
+    cache_seed: int | None = 0,
+    autofix: int = 0,
+    autofix_lm: lf.LanguageModel | None = None,
+    returns_message: bool = False,
+    **kwargs,
+) -> Any:
+  """Async version of `lf.complete`."""
+  # TODO(daiyip): implement native async completion.
+  return await lf.invoke_async(
+      complete,
+      input_value,
+      default,
+      lm=lm,
+      examples=examples,
+      cache_seed=cache_seed,
+      autofix=autofix,
+      autofix_lm=autofix_lm,
+      returns_message=returns_message,
+      **kwargs
+  )

langfun/core/structured/completion_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Tests for langfun.core.structured.completion."""
 
+import asyncio
 import inspect
 import unittest
 
@@ -620,6 +621,41 @@ class CompleteStructureTest(unittest.TestCase):
     ):
       self.assertIsNone(completion.complete(Activity.partial(), None))
 
+  def test_acomplete(self):
+    response = """
+    ```python
+        TripPlan(
+          place='San Francisco',
+          itineraries=[
+            Itinerary(
+                day=1,
+                type='daytime',
+                activities=[
+                    Activity(description='Arrive in San Francisco and check into your hotel.'),
+                    Activity(description='Take a walk around Fisherman\\'s Wharf and have dinner at one of the many seafood restaurants.'),
+                    Activity(description='Visit Pier 39 and see the sea lions.'),
+                ], 
+            ),
+          ]
+        )
+    ```
+    """
+    with lf.context(
+        lm=fake.StaticSequence(
+            [response],
+        ),
+        override_attrs=True,
+    ):
+      r = completion.acomplete(
+          TripPlan.partial(
+              place='San Francisco',
+              itineraries=[
+                  Itinerary.partial(day=1),
+              ],
+          )
+      )
+      self.assertIsInstance(asyncio.run(r), TripPlan)
+
 
 if __name__ == '__main__':
   unittest.main()

langfun/core/structured/parsing.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Symbolic parsing."""
+
 from typing import Any, Callable, Type, Union
 
 import langfun.core as lf
@@ -183,6 +184,44 @@ def parse(
   return output if returns_message else output.result
 
 
+async def aparse(
+    message: Union[lf.Message, str],
+    schema: Union[
+        schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any]
+    ],
+    default: Any = lf.RAISE_IF_HAS_ERROR,
+    *,
+    user_prompt: str | None = None,
+    lm: lf.LanguageModel | None = None,
+    examples: list[mapping.MappingExample] | None = None,
+    include_context: bool = False,
+    cache_seed: int | None = 0,
+    autofix: int = 0,
+    autofix_lm: lf.LanguageModel | None = None,
+    protocol: schema_lib.SchemaProtocol = 'python',
+    returns_message: bool = False,
+    **kwargs,
+) -> Any:
+  """Async version of `lf.parse`."""
+  # TODO(daiyip): implement native async parsing.
+  return await lf.invoke_async(
+      parse,
+      message,
+      schema,
+      default,
+      user_prompt=user_prompt,
+      lm=lm,
+      examples=examples,
+      include_context=include_context,
+      cache_seed=cache_seed,
+      autofix=autofix,
+      autofix_lm=autofix_lm,
+      protocol=protocol,
+      returns_message=returns_message,
+      **kwargs
+  )
+
+
 def call(
     prompt: str | lf.Template,
     schema: Union[
@@ -298,6 +337,44 @@ def call(
   return parsing_message if returns_message else parsing_message.result
 
 
+async def acall(
+    prompt: str | lf.Template,
+    schema: Union[
+        None, schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any]
+    ] = None,
+    *,
+    lm: lf.LanguageModel | None = None,
+    parsing_lm: lf.LanguageModel | None = None,
+    parsing_examples: list[mapping.MappingExample] | None = None,
+    parsing_include_context: bool = False,
+    cache_seed: int | None = 0,
+    autofix: int = 0,
+    autofix_lm: lf.LanguageModel | None = None,
+    response_postprocess: Callable[[str], str] | None = None,
+    protocol: schema_lib.SchemaProtocol = 'python',
+    returns_message: bool = False,
+    **kwargs,
+) -> Any:
+  """Async version of `lf.call`."""
+  # TODO(daiyip): implement native async calling.
+  return await lf.invoke_async(
+      call,
+      prompt,
+      schema,
+      lm=lm,
+      parsing_lm=parsing_lm,
+      parsing_examples=parsing_examples,
+      parsing_include_context=parsing_include_context,
+      cache_seed=cache_seed,
+      autofix=autofix,
+      autofix_lm=autofix_lm,
+      response_postprocess=response_postprocess,
+      protocol=protocol,
+      returns_message=returns_message,
+      **kwargs
+  )
+
+
 def _parse_structure_cls(
     protocol: schema_lib.SchemaProtocol,
 ) -> Type[_ParseStructure]:

langfun/core/structured/parsing_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Tests for structured parsing."""
 
+import asyncio
 import inspect
 import unittest
 
@@ -291,6 +292,10 @@ class ParseStructurePythonTest(unittest.TestCase):
         ),
     )
 
+  def test_aparse(self):
+    with lf.context(lm=fake.StaticResponse('1')):
+      self.assertEqual(asyncio.run(parsing.aparse('the answer is 1', int)), 1)
+
 
 class ParseStructureJsonTest(unittest.TestCase):
 
@@ -583,6 +588,16 @@ class CallTest(unittest.TestCase):
     ):
       self.assertEqual(parsing.call('Compute 1 + 2'), 'three')
 
+  def test_acall(self):
+    with lf.context(
+        lm=fake.StaticMapping({
+            'Compute 1 + 2': 'three',
+        })
+    ):
+      self.assertEqual(
+          asyncio.run(parsing.acall('Compute 1 + 2')), 'three'
+      )
+
   def test_call_with_template_str(self):
     with lf.context(
         lm=fake.StaticMapping({

langfun/core/structured/querying.py

@@ -666,6 +666,48 @@ def query(
   return output_message.text if schema in (None, str) else output_message.result
 
 
+async def aquery(
+    prompt: Union[str, lf.Template, Any],
+    schema: schema_lib.SchemaType |  None = None,
+    default: Any = lf.RAISE_IF_HAS_ERROR,
+    *,
+    lm: lf.LanguageModel | list[lf.LanguageModel] | None = None,
+    num_samples: int | list[int] = 1,
+    system_message: str | lf.Template | None = None,
+    examples: list[mapping.MappingExample] | None = None,
+    cache_seed: int | None = 0,
+    response_postprocess: Callable[[str], str] | None = None,
+    autofix: int = 0,
+    autofix_lm: lf.LanguageModel | None = None,
+    protocol: str | None = None,
+    returns_message: bool = False,
+    skip_lm: bool = False,
+    invocation_id: str | None = None,
+    **kwargs,
+) -> Any:
+  """Async version of `lf.query`."""
+  # TODO(daiyip): implement native async querying.
+  return await lf.invoke_async(
+      query,
+      prompt,
+      schema,
+      default,
+      lm=lm,
+      num_samples=num_samples,
+      system_message=system_message,
+      examples=examples,
+      cache_seed=cache_seed,
+      response_postprocess=response_postprocess,
+      autofix=autofix,
+      autofix_lm=autofix_lm,
+      protocol=protocol,
+      returns_message=returns_message,
+      skip_lm=skip_lm,
+      invocation_id=invocation_id,
+      **kwargs
+  )
+
+
 @contextlib.contextmanager
 def query_protocol(protocol: str) -> Iterator[None]:
   """Context manager for setting the query protocol for the scope."""

langfun/core/structured/querying_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Tests for structured query."""
 
+import asyncio
 import inspect
 import math
 import time
@@ -1336,6 +1337,15 @@ class LfQueryJsonV1Test(unittest.TestCase):
           querying.query('what is 1 + 0', int, lm=lm), 1
       )
 
+  def test_aquery(self):
+    with lf.context(lm=fake.StaticResponse('{"result": 1}')):
+      self.assertEqual(
+          asyncio.run(
+              querying.aquery('what is 1 + 0', int, protocol='json')
+          ),
+          1
+      )
+
 
 class QueryInvocationTest(unittest.TestCase):
 

langfun/core/structured/scoring.py

@@ -179,3 +179,31 @@ def _get_first_oneof(value: Any) -> pg.hyper.OneOf:
   pg.traverse(value, select_oneofs)
   assert oneofs
   return oneofs[0]
+
+
+async def ascore(
+    prompt: Union[str, pg.Symbolic] | list[str | pg.Symbolic],
+    completions: list[str | pg.Symbolic],
+    schema: Union[
+        schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any], None
+    ] = None,
+    *,
+    lm: lf.LanguageModel | None = None,
+    examples: list[mapping.MappingExample] | None = None,
+    protocol: schema_lib.SchemaProtocol = 'python',
+    return_scoring_results: bool = False,
+    **kwargs,
+) -> list[float] | list[lf.LMScoringResult]:
+  """Async version of `lf.score`."""
+  # TODO(daiyip): implement native async scoring.
+  return await lf.invoke_async(
+      score,
+      prompt,
+      completions,
+      schema=schema,
+      lm=lm,
+      examples=examples,
+      protocol=protocol,
+      return_scoring_results=return_scoring_results,
+      **kwargs,
+  )

langfun/core/structured/scoring_test.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
 import unittest
 import langfun.core as lf
 from langfun.core.llms import fake
@@ -50,6 +51,13 @@ class ScoringTest(unittest.TestCase):
   def test_score(self):
     self.assertEqual(scoring.score('hi', [1, 2], lm=fake.Echo()), [0.0, -1.0])
 
+  def test_ascore(self):
+    with lf.context(lm=fake.Echo()):
+      self.assertEqual(
+          asyncio.run(scoring.ascore('hi', [1, 2], lm=fake.Echo())),
+          [0.0, -1.0]
+      )
+
   def test_score_on_field_values(self):
     self.assertEqual(
         scoring.score(

langfun/core/structured/tokenization.py

@@ -62,3 +62,27 @@ def tokenize(
     lm = lm_override.value
 
   return lm.tokenize(input_message)
+
+
+async def atokenize(
+    prompt: Union[str, pg.Symbolic] | list[str | pg.Symbolic],
+    schema: Union[
+        schema_lib.Schema, Type[Any], list[Type[Any]], dict[str, Any], None
+    ] = None,
+    *,
+    lm: lf.LanguageModel | None = None,
+    examples: list[mapping.MappingExample] | None = None,
+    protocol: schema_lib.SchemaProtocol = 'python',
+    **kwargs,
+) -> list[tuple[str | bytes, int]]:
+  """Async version of `lf.tokenize`."""
+  # TODO(daiyip): implement native async tokenization.
+  return await lf.invoke_async(
+      tokenize,
+      prompt,
+      schema,
+      lm=lm,
+      examples=examples,
+      protocol=protocol,
+      **kwargs,
+  )

langfun/core/structured/tokenization_test.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
 import unittest
 import langfun.core as lf
 from langfun.core.llms import fake
@@ -36,6 +37,13 @@ class TokenizationTest(unittest.TestCase):
         [('hi', 0)]
     )
 
+  def test_atokenize(self):
+    with lf.context(lm=fake.Echo()):
+      self.assertEqual(
+          asyncio.run(tokenization.atokenize('hi')),
+          [('hi', 0)]
+      )
+
   def test_tokenize_with_lm_from_the_context(self):
     with lf.context(lm=fake.Echo()):
       self.assertEqual(

{langfun-0.1.2.dev202507250804.dist-info → langfun-0.1.2.dev202507260804.dist-info}/METADATA

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

{langfun-0.1.2.dev202507250804.dist-info → langfun-0.1.2.dev202507260804.dist-info}/RECORD

@@ -1,5 +1,7 @@
 langfun/__init__.py,sha256=krEJ1lyDkNARsacY6nBQpD3bQrFi4fifD-FwpwPbFPM,2635
-langfun/core/__init__.py,sha256=pW4prpiyWNkRbtWBGYF1thn7_0F_TgDVfAIZPvGn6HA,4758
+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/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
@@ -8,8 +10,8 @@ langfun/core/console.py,sha256=cLQEf84aDxItA9fStJV22xJch0TqFLNf9hLqwJ0RHmU,2652
 langfun/core/console_test.py,sha256=pBOcuNMJdVELywvroptfcRtJMsegMm3wSlHAL2TdxVk,1679
 langfun/core/langfunc.py,sha256=G50YgoVZ0y1GFw2ev41MlOqr6qa8YakbvNC0h_E0PiA,11140
 langfun/core/langfunc_test.py,sha256=CDn-gJCa5EnjN7cotAVCfSCbuzddq2o-HzEt7kV8HbY,8882
-langfun/core/language_model.py,sha256=5i0Je5526JO2YY6qExi6Yf7VQVgSVeZIKOjt3I8kxqQ,49573
-langfun/core/language_model_test.py,sha256=9EofP3_gTH28SNWiOKzTUYMHH0EYtbi9xGuT1KZT1XU,37330
+langfun/core/language_model.py,sha256=T3Gyb0-S4uRunO9EotTN5-86Dc3Bw6tE4Db43qDMqOc,51042
+langfun/core/language_model_test.py,sha256=aJWn3UJm_S6U7VhU7EVXdJHPe1xza5glngPkRGtx280,38426
 langfun/core/logging.py,sha256=7IGAhp7mGokZxxqtL-XZvFLKaZ5k3F5_Xp2NUtR4GwE,9136
 langfun/core/logging_test.py,sha256=vbVGOQxwMmVSiFfbt2897gUt-8nqDpV64jCAeUG_q5U,6924
 langfun/core/memory.py,sha256=vyXVvfvSdLLJAzdIupnbn3k26OgclCx-OJ7gddS5e1Y,2070
@@ -26,10 +28,10 @@ langfun/core/subscription_test.py,sha256=Y4ZdbZEwm83YNZBxHff0QR4QUa4rdaNXA3_jfIc
 langfun/core/template.py,sha256=jNhYSrbLIn9kZOa03w5QZbyjgfnzJzE_ZrrMvvWY4t4,24929
 langfun/core/template_test.py,sha256=AQv_m9qE93WxhEhSlm1xaBgB4hu0UVtA53dljngkUW0,17090
 langfun/core/agentic/__init__.py,sha256=qR3jlfUO4rhIoYdRDLz-d22YZf3FvU4FW88vsjiGDQQ,1224
-langfun/core/agentic/action.py,sha256=ngBN__OUjMrw4eg8ljHKQ7VY-EABW8T7gF1nw_ZkQmM,50673
+langfun/core/agentic/action.py,sha256=HvCaYb3x9tpa0xhDuFtEGyZ9du_edDpIdaQYPPo87ts,51097
 langfun/core/agentic/action_eval.py,sha256=YTilyUEkJl_8FVMgdfO17PurWWaEJ6oA15CuefJJRLk,4887
 langfun/core/agentic/action_eval_test.py,sha256=7AkOwNbUX-ZgR1R0a7bvUZ5abNTUV7blf_8Mnrwb-II,2811
-langfun/core/agentic/action_test.py,sha256=46piw5J7vGwmJGjmVG13HQRBmp5TLgkV_ymJ2EQVEIc,15867
+langfun/core/agentic/action_test.py,sha256=5ZUCbyuJDwNCUE_hl4qt5epzQQTRdZEYN5W8J2iKRQo,16084
 langfun/core/coding/__init__.py,sha256=5utju_fwEsImaiftx4oXKl9FAM8p281k8-Esdh_-m1w,835
 langfun/core/coding/python/__init__.py,sha256=yTXm92oLpQb4A-fZ2qy-bzfhPYND7B-oidtbv1PNaX0,1678
 langfun/core/coding/python/correction.py,sha256=4PD76Xfv36Xrm8Ji3-GgGDNImtcDqWfMw3z6ircJMlM,7285
@@ -126,27 +128,27 @@ langfun/core/modalities/pdf.py,sha256=mfaeCbUA4JslFVTARiJh8hW7imvL4tLVw9gUhO5bAZ
 langfun/core/modalities/pdf_test.py,sha256=ulZ0FbnlsU0wkrdckJ4ONZPTYRyMPO9Aob1UO6FXygk,1950
 langfun/core/modalities/video.py,sha256=vI9apcHIHGyp90i34Srg7S3G6IBDtDCk8qiXhwRQmkw,967
 langfun/core/modalities/video_test.py,sha256=7OXZoohKMYjt7vrJUdPb553HLyl1oBOKRgzBePFv68Q,2042
-langfun/core/structured/__init__.py,sha256=xWO1RO-gy12REgiPn4oWWALZxJhHtBOOdDsawKN_SfY,3334
-langfun/core/structured/completion.py,sha256=yW95Yd4wbt964I5wIyPUtIVeeqeZbA6HidLgN0ZpWm0,8110
-langfun/core/structured/completion_test.py,sha256=VtYfI3ciVSSWbi8x3l1WwpWK-Ofn2DMHYEEqm2uTzhw,19314
+langfun/core/structured/__init__.py,sha256=uc9f2DaXcbPRU35CgTpObub6hsnxDCHx-4s149qnzJ0,3655
+langfun/core/structured/completion.py,sha256=B0PHqBucu-keexJUa5g0F9fu57DlLtWDhZzJ-OD4VrE,8823
+langfun/core/structured/completion_test.py,sha256=-SGcMgtLuS6RQB8gFh18dUkSMQMDWKZGmBkPsAYHApQ,20348
 langfun/core/structured/description.py,sha256=6BztYOiucPkF4CrTQtPLPJo1gN2dwnKmaJW83GBf4H0,5213
 langfun/core/structured/description_test.py,sha256=UxaXnKKP7TnyPDPUyf3U-zPE0TvLlIP6DGr8thjcePw,7365
 langfun/core/structured/function_generation.py,sha256=g7AOR_e8HxFU6n6Df750aGkgMgV1KExLZMAz0yd5Agg,8555
 langfun/core/structured/function_generation_test.py,sha256=LaXYDXf9GlqUrR6v_gtmK_H4kxzonmU7SYbn7XXMgjU,12128
 langfun/core/structured/mapping.py,sha256=1YBW8PKpJKXS7DKukfzKNioL84PrKUcB4KOUudrQ20w,14374
 langfun/core/structured/mapping_test.py,sha256=OntYvfDitAf0tAnzQty3YS90vyEn6FY1Mi93r_ViEk8,9594
-langfun/core/structured/parsing.py,sha256=MGvI7ypXlwfzr5XB8_TFU9Ei0_5reYqkWkv64eAy0EA,12015
-langfun/core/structured/parsing_test.py,sha256=V8Cj1tJK4Lxv_b0YQj6-2hzXZgnYNBa2JR7rOLRBKoQ,22346
-langfun/core/structured/querying.py,sha256=vE_NOLNlIe4A0DueQfyiBEUh3AsSD8Hhx2dSDHNYpYk,37976
-langfun/core/structured/querying_test.py,sha256=Q0HwmbUI9BqMaeN8vgn_EvX29CzfcomGIKVqKJ6dZyY,50212
+langfun/core/structured/parsing.py,sha256=bLi7o1AdyDWc6TwxmYg70t_oTgmLkJWBafakdF8n2RI,14195
+langfun/core/structured/parsing_test.py,sha256=vRfCSzA9q7C1cElkAnDvbRepULEa_vclqDIv-heypDw,22745
+langfun/core/structured/querying.py,sha256=LV7ZCiVx2ef1Qx_ONwexzSvCSBSq1V41E8RdxHDGP-g,39225
+langfun/core/structured/querying_test.py,sha256=klj9OmLKzJbsTYSil58Lex_PVaIlt3ngWQziibg9i4g,50464
 langfun/core/structured/schema.py,sha256=xtgrr3t5tcYQ2gi_fkTKz2IgDMf84gpiykmBdfnV6Io,29486
 langfun/core/structured/schema_generation.py,sha256=pEWeTd8tQWYnEHukas6GVl4uGerLsQ2aNybtnm4Qgxc,5352
 langfun/core/structured/schema_generation_test.py,sha256=RM9s71kMNg2jTePwInkiW9fK1ACN37eyPeF8OII-0zw,2950
 langfun/core/structured/schema_test.py,sha256=H42ZZdPi8CIv7WzrnXwMwQQaPQxlmDSY31pfqQs-Xqw,26567
-langfun/core/structured/scoring.py,sha256=Y7Jqs5VVjUQLF_9Z1uIY_dw5zasv2FF52Cz-cxGMsro,5857
-langfun/core/structured/scoring_test.py,sha256=QvlwDAzwuamKL5tCotm1L3Sx0cs3idoNK4aIEhaO4Yk,2272
-langfun/core/structured/tokenization.py,sha256=-b4_693quHeYn2AqndwucuXNmhd5NVXVTU3mmDane98,2189
-langfun/core/structured/tokenization_test.py,sha256=dVW30kGYkX2HNtiRZe1oTmXFP7iIK6PrlKCttZ3QXe4,1311
+langfun/core/structured/scoring.py,sha256=59B6zJt190EtwT2aIgVvCL7X1k8Nk5d1m0OSI4qbBqk,6671
+langfun/core/structured/scoring_test.py,sha256=msxtZX1MWgoLTWkmM-McbUo-qGev0uDdlXLm4kPiIiE,2473
+langfun/core/structured/tokenization.py,sha256=zAfzS8OOjMEz_GqGiTs3GGplPEwvkdCb_EoGF96Lwz4,2845
+langfun/core/structured/tokenization_test.py,sha256=8IXndRokZmlLPZD_jIitfhgcRxBjmG09PhT-WLHe9dw,1499
 langfun/core/templates/__init__.py,sha256=bO0eMsVJbi7sxEB2YlInKRQ2EVP-RyyKUwcD-8msuN4,927
 langfun/core/templates/completion.py,sha256=mUqZHOEV3ag6-A08XghpeEltcrBvCDxXP004eDDfeag,1931
 langfun/core/templates/completion_test.py,sha256=vGnjnM38UHyVDUyaUYtmp20s9KBGOdbPVsX-H-ET11E,1636
@@ -156,8 +158,8 @@ langfun/core/templates/demonstration.py,sha256=vCrgYubdZM5Umqcgp8NUVGXgr4P_c-fik
 langfun/core/templates/demonstration_test.py,sha256=SafcDQ0WgI7pw05EmPI2S4v1t3ABKzup8jReCljHeK4,2162
 langfun/core/templates/selfplay.py,sha256=yhgrJbiYwq47TgzThmHrDQTF4nDrTI09CWGhuQPNv-s,2273
 langfun/core/templates/selfplay_test.py,sha256=Ot__1P1M8oJfoTp-M9-PQ6HUXqZKyMwvZ5f7yQ3yfyM,2326
-langfun-0.1.2.dev202507250804.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-langfun-0.1.2.dev202507250804.dist-info/METADATA,sha256=OijvzDGb01eLWEje73bqNewaGsyvQVLL8E-QFoOF3GU,7380
-langfun-0.1.2.dev202507250804.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-langfun-0.1.2.dev202507250804.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
-langfun-0.1.2.dev202507250804.dist-info/RECORD,,
+langfun-0.1.2.dev202507260804.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+langfun-0.1.2.dev202507260804.dist-info/METADATA,sha256=9grI0Yk9pnRLTDke08_k9my8IkhFJsPY72qg2xGRxPA,7380
+langfun-0.1.2.dev202507260804.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+langfun-0.1.2.dev202507260804.dist-info/top_level.txt,sha256=RhlEkHxs1qtzmmtWSwYoLVJAc1YrbPtxQ52uh8Z9VvY,8
+langfun-0.1.2.dev202507260804.dist-info/RECORD,,