langfun 0.1.2.dev202505050805__tar.gz → 0.1.2.dev202505070805__tar.gz

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/PKG-INFO

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

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/agentic/action.py

@@ -194,6 +194,11 @@ class Action(pg.Object):
     """Returns the metadata associated with the result from previous call."""
     return self._invocation.metadata if self._invocation else None
 
+  @property
+  def invocation(self) -> Optional['ActionInvocation']:
+    """Returns last invocation. None if the action is not executed."""
+    return self._invocation
+
   def __call__(
       self,
       session: Optional['Session'] = None,
@@ -825,6 +830,7 @@ class ActionInvocation(pg.Object, pg.views.html.HtmlTreeView.Extension):
   def _on_bound(self):
     super()._on_bound()
     self._tab_control = None
+    self.action._invocation = self    # pylint: disable=protected-access
 
   def _on_parent_change(self, *args, **kwargs):
     super()._on_parent_change(*args, **kwargs)
@@ -1154,7 +1160,6 @@ class Session(pg.Object, pg.views.html.HtmlTreeView.Extension):
       )
 
     invocation = ActionInvocation(pg.maybe_ref(action))
-    action._invocation = invocation  # pylint: disable=protected-access
     parent_action = self._current_action
     parent_execution = self._current_execution
     parent_execution.append(invocation)
@@ -1412,38 +1417,103 @@ class Session(pg.Object, pg.views.html.HtmlTreeView.Extension):
       level: lf.logging.LogLevel,
       message: str,
       keep: bool,
+      *,
+      for_action: Action | ActionInvocation | None = None,
       **kwargs
   ) -> None:
-    """Logs a message to the session."""
-    action_name = self._current_action.action.__class__.__name__
+    """Logs a message to the session.
+
+    Args:
+      level: The logging level.
+      message: The message to log.
+      keep: Whether to keep the log entry in the execution trace.
+      for_action: The action to log the message for. If not provided, the
+        current action will be used.
+      **kwargs: Additional keyword arguments to pass to `lf.logging.log` as
+        metadata to show.
+    """
     execution = self._current_execution
+    if for_action is None:
+      for_action = self._current_action
+    elif isinstance(for_action, Action):
+      for_action = for_action.invocation
+      assert for_action is not None
+
     log_entry = lf.logging.log(
         level,
-        f'[{execution.id} ({action_name})]: {message}',
+        (
+            f'[{for_action.id} ({for_action.action.__class__.__name__})]: '
+            f'{message}'
+        ),
         **kwargs
     )
     if keep:
       execution.append(log_entry)
 
-  def debug(self, message: str, keep: bool = True, **kwargs):
+  def debug(
+      self,
+      message: str,
+      keep: bool = True,
+      *,
+      for_action: Action | ActionInvocation | None = None,
+      **kwargs
+  ) -> None:
     """Logs a debug message to the session."""
-    self._log('debug', message, keep=keep, **kwargs)
+    self._log(
+        'debug', message, keep=keep, for_action=for_action, **kwargs
+    )
 
-  def info(self, message: str, keep: bool = True, **kwargs):
+  def info(
+      self,
+      message: str,
+      keep: bool = True,
+      *,
+      for_action: Action | ActionInvocation | None = None,
+      **kwargs
+  ) -> None:
     """Logs an info message to the session."""
-    self._log('info', message, keep=keep, **kwargs)
+    self._log(
+        'info', message, keep=keep, for_action=for_action, **kwargs
+    )
 
-  def warning(self, message: str, keep: bool = True, **kwargs):
+  def warning(
+      self,
+      message: str,
+      keep: bool = True,
+      *,
+      for_action: Action | ActionInvocation | None = None,
+      **kwargs
+  ) -> None:
     """Logs a warning message to the session."""
-    self._log('warning', message, keep=keep, **kwargs)
+    self._log(
+        'warning', message, keep=keep, for_action=for_action, **kwargs
+    )
 
-  def error(self, message: str, keep: bool = True, **kwargs):
+  def error(
+      self,
+      message: str,
+      keep: bool = True,
+      *,
+      for_action: Action | ActionInvocation | None = None,
+      **kwargs
+  ):
     """Logs an error message to the session."""
-    self._log('error', message, keep=keep, **kwargs)
+    self._log(
+        'error', message, keep=keep, for_action=for_action, **kwargs
+    )
 
-  def fatal(self, message: str, **kwargs):
+  def fatal(
+      self,
+      message: str,
+      keep: bool = True,
+      *,
+      for_action: Action | ActionInvocation | None = None,
+      **kwargs
+  ):
     """Logs a fatal message to the session."""
-    self._log('fatal', message, keep=True, **kwargs)
+    self._log(
+        'fatal', message, keep=keep, for_action=for_action, **kwargs
+    )
 
   def as_message(self) -> lf.AIMessage:
     """Returns the session as a message."""

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/agentic/action_test.py

@@ -107,6 +107,7 @@ class SessionTest(unittest.TestCase):
     lm = fake.StaticResponse('lm response')
     foo = Foo(1)
     self.assertIsNone(foo.session)
+    self.assertIsNone(foo.invocation)
     self.assertIsNone(foo.result)
     self.assertIsNone(foo.metadata)
 
@@ -167,6 +168,7 @@ class SessionTest(unittest.TestCase):
 
     # Inspecting the top-level action (Foo)
     foo_invocation = root.execution[0]
+    self.assertIs(foo.invocation, foo_invocation)
     self.assertIs(foo_invocation.parent_action, root)
     self.assertEqual(foo_invocation.id, 'agent@1:/a1')
     self.assertEqual(foo_invocation.execution.id, 'agent@1:/a1')
@@ -414,8 +416,8 @@ class SessionTest(unittest.TestCase):
   def test_log(self):
     session = action_lib.Session()
     session.debug('hi', x=1, y=2)
-    session.info('hi', x=1, y=2)
-    session.warning('hi', x=1, y=2)
+    session.info('hi', x=1, y=2, for_action=session.root)
+    session.warning('hi', x=1, y=2, for_action=session.root.action)
     session.error('hi', x=1, y=2)
     session.fatal('hi', x=1, y=2)
 

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/llms/__init__.py

@@ -40,6 +40,7 @@ from langfun.core.llms.azure_openai import AzureOpenAI
 
 # Gemini models.
 from langfun.core.llms.google_genai import GenAI
+from langfun.core.llms.google_genai import Gemini25ProPreview_20250506
 from langfun.core.llms.google_genai import Gemini25FlashPreview_20250417
 from langfun.core.llms.google_genai import Gemini25ProPreview_20250325
 from langfun.core.llms.google_genai import Gemini2Flash
@@ -77,6 +78,7 @@ from langfun.core.llms.vertexai import VertexAIGeminiExp_20241206
 from langfun.core.llms.vertexai import VertexAIGemini25ProExp_20250325
 from langfun.core.llms.vertexai import VertexAIGemini25ProPreview_20250325
 from langfun.core.llms.vertexai import VertexAIGemini25FlashPreview_20250417
+from langfun.core.llms.vertexai import VertexAIGemini25ProPreview_20250506
 
 # For backward compatibility.
 GeminiPro1_5 = Gemini15Pro
@@ -87,6 +89,7 @@ VertexAIGeminiFlash1_5 = VertexAIGemini15Flash
 # OpenAI models.
 from langfun.core.llms.openai import OpenAI
 
+from langfun.core.llms.openai import Gpt41
 from langfun.core.llms.openai import GptO3
 from langfun.core.llms.openai import GptO4Mini
 from langfun.core.llms.openai import Gpt45Preview_20250227

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/llms/gemini.py

@@ -151,6 +151,29 @@ SUPPORTED_MODELS = [
     #
     # Production models.
     #
+    # Gemini 2.5 Pro Preview
+    GeminiModelInfo(
+        model_id='gemini-2.5-pro-preview-05-06',
+        in_service=True,
+        provider=pg.oneof(['Google GenAI', ' VertexAI']),
+        model_type='instruction-tuned',
+        description='Gemini 2.5 Pro.',
+        release_date=datetime.datetime(2025, 5, 6),
+        input_modalities=GeminiModelInfo.ALL_SUPPORTED_INPUT_TYPES,
+        context_length=lf.ModelInfo.ContextLength(
+            max_input_tokens=1_048_576,
+            max_output_tokens=65_536,
+        ),
+        pricing=GeminiModelInfo.Pricing(
+            cost_per_1m_cached_input_tokens=1.25,
+            cost_per_1m_input_tokens=1.25,
+            cost_per_1m_output_tokens=10.0,
+        ),
+        rate_limits=lf.ModelInfo.RateLimits(
+            max_requests_per_minute=2000,
+            max_tokens_per_minute=4_000_000,
+        )
+    ),
     # Gemini 2.5 Flash Preview
     GeminiModelInfo(
         model_id='gemini-2.5-flash-preview-04-17',
@@ -657,7 +680,7 @@ class Gemini(rest.REST):
   def result(self, json: dict[str, Any]) -> lf.LMSamplingResult:
     messages = [
         lf.Message.from_value(candidate['content'], format='gemini')
-        for candidate in json['candidates']
+        for candidate in json.get('candidates', [])
     ]
     usage = json['usageMetadata']
     input_tokens = usage['promptTokenCount']

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/llms/google_genai.py

@@ -106,6 +106,10 @@ class GeminiExp_20241206(GenAI):
 #
 # Production models.
 #
+class Gemini25ProPreview_20250506(GenAI):
+  """Gemini 2.5 Pro model launched on 05/06/2025."""
+
+  model = 'gemini-2.5-pro-preview-05-06'
 
 
 class Gemini25FlashPreview_20250417(GenAI):

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/llms/openai.py

@@ -49,6 +49,30 @@ class OpenAIModelInfo(lf.ModelInfo):
 #
 
 SUPPORTED_MODELS = [
+    # GPT-4.1 models
+    OpenAIModelInfo(
+        model_id='gpt-4.1',
+        alias_for='gpt-4.1-2025-04-14',
+        in_service=True,
+        model_type='instruction-tuned',
+        description='GPT 4.1 model (latest stable).',
+        url='https://platform.openai.com/docs/models/gpt-4.1',
+        input_modalities=OpenAIModelInfo.INPUT_IMAGE_TYPES,
+        context_length=lf.ModelInfo.ContextLength(
+            max_input_tokens=1_047_576,
+            max_output_tokens=32_768,
+        ),
+        pricing=lf.ModelInfo.Pricing(
+            cost_per_1m_cached_input_tokens=0.50,
+            cost_per_1m_input_tokens=2.0,
+            cost_per_1m_output_tokens=8.0,
+        ),
+        # Tier 5 rate limits.
+        rate_limits=lf.ModelInfo.RateLimits(
+            max_requests_per_minute=10_000,
+            max_tokens_per_minute=30_000_000,
+        ),
+    ),
     # o3 models.
     OpenAIModelInfo(
         model_id='o3',
@@ -1045,6 +1069,11 @@ class OpenAI(openai_compatible.OpenAICompatible):
     return super()._request_args(options)
 
 
+class Gpt41(OpenAI):
+  """GPT-4.1."""
+  model = 'gpt-4.1'
+
+
 class GptO4Mini(OpenAI):
   """GPT O4 mini."""
 

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/llms/vertexai.py

@@ -173,9 +173,13 @@ class VertexAIGemini(VertexAI, gemini.Gemini):
   def model_info(self) -> gemini.GeminiModelInfo:
     return super().model_info.clone(override=dict(provider='VertexAI'))
 
+
 #
 # Production models.
 #
+class VertexAIGemini25ProPreview_20250506(VertexAIGemini):  # pylint: disable=invalid-name
+  """Gemini 2.5 Pro model launched on 05/06/2025."""
+  model = 'gemini-2.5-pro-preview-05-06'
 
 
 class VertexAIGemini25FlashPreview_20250417(VertexAIGemini):  # pylint: disable=invalid-name

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/memories/conversation_history.py

@@ -43,19 +43,19 @@ class ConversationHistory(lf.Memory):
       messages.append(r[1])
     return messages
 
-  def _recollect(self, **kwargs) -> lf.MemoryRecord:
-    return lf.MemoryRecord(
-        '\n'.join([f'{m.sender}: {m.text}' for m in self.messages]))
+  def _recollect(self, **kwargs) -> str:
+    return '\n'.join([f'{m.sender}: {m.text}' for m in self.messages])
 
   def _remember(
       self,
-      input_message: lf.Message,
-      output_message: lf.Message | None = None,
+      value: tuple[str | lf.Message, str | lf.Message],
       **kwargs
   ) -> None:
     if self.max_turns and self.max_turns == len(self._turns):
       self._turns.pop(0)
-    self._turns.append((input_message, output_message))
+    self._turns.append(
+        (lf.UserMessage.from_value(value[0]), lf.AIMessage.from_value(value[1]))
+    )
 
   def _reset(self, **kwargs) -> None:
     self._turns = []

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/memories/conversation_history_test.py

@@ -13,58 +13,62 @@
 # limitations under the License.
 """Base memory test."""
 
-import inspect
 import unittest
 import langfun.core as lf
 from langfun.core.memories.conversation_history import ConversationHistory
+import pyglove as pg
 
 
 class ConversationHistoryTest(unittest.TestCase):
 
   def test_history_with_no_round_limit(self):
     m = ConversationHistory()
-    m.remember('hi', 'hello')
+    m.remember(('hi', 'hello'))
     m.remember(
-        'how are you',
-        'Fine, thank you. Anything I can help with?',
+        ('how are you', 'Fine, thank you. Anything I can help with?'),
     )
     m.remember(
-        'Not for now, bye.',
-        'Okay, bye!',
+        ('Not for now, bye.', 'Okay, bye!'),
     )
     self.assertEqual(len(m.turns), 3)
     self.assertEqual(len(m.messages), 6)
-    self.assertEqual(
-        m.recollect(),
-        lf.MemoryRecord(inspect.cleandoc("""
-            User: hi
-            AI: hello
-            User: how are you
-            AI: Fine, thank you. Anything I can help with?
-            User: Not for now, bye.
-            AI: Okay, bye!
-            """)),
+    self.assertTrue(
+        pg.eq(
+            m.recollect(),
+            lf.Template(
+                """
+                User: hi
+                AI: hello
+                User: how are you
+                AI: Fine, thank you. Anything I can help with?
+                User: Not for now, bye.
+                AI: Okay, bye!
+                """
+            )
+        )
     )
 
   def test_history_with_round_limit(self):
     m = ConversationHistory(max_turns=1)
-    m.remember('hi', 'hello')
+    m.remember(('hi', 'hello'))
     m.remember(
-        'how are you',
-        'Fine, thank you. Anything I can help with?',
+        ('how are you', 'Fine, thank you. Anything I can help with?'),
     )
     m.remember(
-        'Not for now, bye.',
-        'Okay, bye!',
+        ('Not for now, bye.', 'Okay, bye!'),
     )
     self.assertEqual(len(m.turns), 1)
     self.assertEqual(len(m.messages), 2)
-    self.assertEqual(
-        m.recollect(),
-        lf.MemoryRecord(inspect.cleandoc("""
-            User: Not for now, bye.
-            AI: Okay, bye!
-            """)),
+    self.assertTrue(
+        pg.eq(
+            m.recollect(),
+            lf.Template(
+                """
+                User: Not for now, bye.
+                AI: Okay, bye!
+                """
+            )
+        )
     )
 
 

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/memory.py

@@ -14,7 +14,9 @@
 """Interface for memories."""
 
 import abc
-from langfun.core import message as message_lib
+from typing import Any
+
+from langfun.core import template as template_lib
 from langfun.core.component import Component
 from langfun.core.natural_language import NaturalLanguageFormattable
 
@@ -30,40 +32,29 @@ class Memory(NaturalLanguageFormattable, Component):
   """
 
   def natural_language_format(self) -> str:
-    return self.recollect().text
+    return self.recollect().render().text
 
-  def recollect(self, **kwargs) -> message_lib.MemoryRecord:
+  def recollect(self, **kwargs) -> template_lib.Template:
     """Recollects a message from the memory."""
-    return self._recollect(**kwargs)
+    return template_lib.Template.from_value(self._recollect(**kwargs))
 
   def remember(
       self,
-      input_message: str | message_lib.Message,
-      output_message: str | message_lib.Message,
+      value: Any,
       **kwargs
-  ) -> str:
-    if isinstance(input_message, str):
-      input_message = message_lib.UserMessage(input_message)
-    if isinstance(output_message, str):
-      output_message = message_lib.AIMessage(output_message)
-    self._remember(input_message, output_message, **kwargs)
-    return output_message.text
+  ) -> None:
+    self._remember(value, **kwargs)
 
   def reset(self, **kwargs) -> None:
     """Resets the memory."""
-    self._reset()
+    self._reset(**kwargs)
 
   @abc.abstractmethod
-  def _recollect(self, **kwargs) -> message_lib.MemoryRecord:
+  def _recollect(self, **kwargs) -> str | template_lib.Template:
     """Recollects a message from the memory."""
 
   @abc.abstractmethod
-  def _remember(
-      self,
-      input_message: message_lib.Message,
-      output_message: message_lib.Message,
-      **kwargs
-  ) -> None:
+  def _remember(self, value: Any, **kwargs) -> None:
     """Remembers the input message and the output message."""
 
   @abc.abstractmethod

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/structured/schema.py

@@ -185,10 +185,14 @@ class Schema(
   def class_dependencies(
       self,
       include_base_classes: bool = True,
-      include_subclasses: bool = True) -> list[Type[Any]]:
+      include_subclasses: bool = True,
+      include_generated_subclasses: bool = False) -> list[Type[Any]]:
     """Returns a list of class dependencies for current schema."""
     return class_dependencies(
-        self.spec, include_base_classes, include_subclasses
+        self.spec,
+        include_base_classes,
+        include_subclasses,
+        include_generated_subclasses
     )
 
   @classmethod
@@ -247,6 +251,7 @@ def class_dependencies(
     ],
     include_base_classes: bool = True,
     include_subclasses: bool = True,
+    include_generated_subclasses: bool = False,
 ) -> list[Type[Any]]:
   """Returns a list of class dependencies from a value or specs."""
   if isinstance(value_or_spec, Schema):
@@ -301,7 +306,12 @@ def class_dependencies(
       # Check subclasses if available.
       if include_subclasses:
         for cls in vs.cls.__subclasses__():
-          if cls not in dependencies:
+          # NOTE(daiyip): To prevent LLM-generated "hallucinated" classes from
+          # polluting the generation space, classes dynamically created by
+          # 'eval' (which have __module__ == 'builtins') are excluded from
+          # dependencies by default.
+          if ((include_generated_subclasses or cls.__module__ != 'builtins')
+              and cls not in dependencies):
             _fill_dependencies(pg.typing.Object(cls), include_subclasses=True)
 
     if isinstance(vs, pg.typing.List):

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/structured/schema_test.py

@@ -144,6 +144,14 @@ class SchemaTest(unittest.TestCase):
       foo2: Foo | X
 
     schema = schema_lib.Schema([B])
+    v = schema_lib.structure_from_python(
+        """
+        class C(B):
+          pass
+        """,
+        global_vars=dict(B=B)
+    )
+    self.assertEqual(v.__module__, 'builtins')
     self.assertEqual(schema.class_dependencies(), [Foo, A, Bar, X, B])
 
   def test_class_dependencies_non_pyglove(self):
@@ -162,6 +170,14 @@ class SchemaTest(unittest.TestCase):
     class BB(AA):
       foo2: Baz | XX
 
+    v = schema_lib.structure_from_python(
+        """
+        class CC(BB):
+          pass
+        """,
+        global_vars=dict(BB=BB)
+    )
+    self.assertEqual(v.__module__, 'builtins')
     schema = schema_lib.Schema([AA])
     self.assertEqual(schema.class_dependencies(), [Baz, AA, XX, BB])
 

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun/core/templates/conversation.py

@@ -90,7 +90,7 @@ class Conversation(Completion):
       self, input_message: lf.Message | str, lm_response: lf.Message | str
   ) -> None:
     """Adds a turn."""
-    self.memory.remember(input_message, lm_response)
+    self.memory.remember((input_message, lm_response))
 
   def reset(self) -> None:
     """Resets current conversation."""

{langfun-0.1.2.dev202505050805 → langfun-0.1.2.dev202505070805}/langfun.egg-info/PKG-INFO

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