langfun 0.0.2.dev20240605__py3-none-any.whl → 0.0.2.dev20240613__py3-none-any.whl

langfun/core/__init__.py

@@ -101,6 +101,7 @@ from langfun.core.language_model import LanguageModel
 from langfun.core.language_model import LMSample
 from langfun.core.language_model import LMSamplingOptions
 from langfun.core.language_model import LMSamplingUsage
+from langfun.core.language_model import UsageNotAvailable
 from langfun.core.language_model import LMSamplingResult
 from langfun.core.language_model import LMScoringResult
 from langfun.core.language_model import LMCache
@@ -111,12 +112,21 @@ from langfun.core.language_model import RetryableLMError
 from langfun.core.language_model import RateLimitError
 from langfun.core.language_model import TemporaryLMError
 
+# Context manager for tracking usages.
+from langfun.core.language_model import track_usages
+
 # Components for building agents.
 from langfun.core.memory import Memory
 
 # Utility for console output.
 from langfun.core import console
 
+# Helpers for implementing _repr_xxx_ methods.
+from langfun.core import repr_utils
+
+# Utility for event logging.
+from langfun.core import logging
+
 # Import internal modules.
 
 # pylint: enable=g-import-not-at-top

langfun/core/component.py

@@ -210,6 +210,16 @@ def get_contextual_override(var_name: str) -> ContextualOverride | None:
   return _get_scoped_value(_global_tls, _CONTEXT_OVERRIDES, var_name)
 
 
+def context_value(var_name: str, default: Any = RAISE_IF_HAS_ERROR) -> Any:
+  """Returns the value of a variable defined in `lf.context`."""
+  override = get_contextual_override(var_name)
+  if override is None:
+    if default == RAISE_IF_HAS_ERROR:
+      raise KeyError(f'{var_name!r} does not exist in current context.')
+    return default
+  return override.value
+
+
 def all_contextual_values() -> dict[str, Any]:
   """Returns all contextual values provided from `lf.context` in scope."""
   overrides = getattr(_global_tls, _CONTEXT_OVERRIDES, {})

langfun/core/component_test.py

@@ -84,6 +84,11 @@ class ComponentContextTest(unittest.TestCase):
           lf.get_contextual_override('y'),
           lf.ContextualOverride(3, cascade=False, override_attrs=False),
       )
+      self.assertEqual(lf.context_value('x'), 3)
+      self.assertIsNone(lf.context_value('f', None))
+      with self.assertRaisesRegex(KeyError, '.* does not exist'):
+        lf.context_value('f')
+
       self.assertEqual(lf.all_contextual_values(), dict(x=3, y=3, z=3))
 
       # Member attributes take precedence over `lf.context`.

langfun/core/eval/base.py

@@ -549,7 +549,7 @@ class Evaluable(lf.Component):
         )
         s.write(html.escape(pg.format(m.result)))
         s.write('</div>')
-      if 'usage' in m.metadata and m.usage is not None:
+      if m.metadata.get('usage', None):
         s.write(
             '<div style="background-color: #EEEEEE; color: black; '
             'white-space: pre-wrap; padding: 10px; border: 0px solid; '
@@ -1321,7 +1321,7 @@ class Evaluation(Evaluable):
       self._render_summary_metrics(s)
 
       # Summarize average usage.
-      if self.result.usage is not None:
+      if self.result.usage:
         self._render_summary_usage(s)
 
     s.write('</td></tr></table></div>')
@@ -1441,9 +1441,10 @@ class Evaluation(Evaluable):
   def audit_usage(self, message: lf.Message, dryrun: bool = False) -> None:
     del dryrun
     for m in message.trace():
-      if m.metadata.get('usage', None) is not None:
-        self._total_prompt_tokens += m.usage.prompt_tokens
-        self._total_completion_tokens += m.usage.completion_tokens
+      usage = m.metadata.get('usage', None)
+      if usage:
+        self._total_prompt_tokens += usage.prompt_tokens
+        self._total_completion_tokens += usage.completion_tokens
         self._num_usages += 1
 
   def audit_processed(
@@ -1504,7 +1505,7 @@ class Evaluation(Evaluable):
         '<td>Schema</td>'
         '<td>Additional Args</td>'
     )
-    if self.result.usage is not None:
+    if self.result.usage:
       s.write('<td>Usage</td>')
     s.write('<td>OOP Failures</td>')
     s.write('<td>Non-OOP Failures</td>')
@@ -1533,7 +1534,7 @@ class Evaluation(Evaluable):
         f'{_html_repr(self.additional_args, compact=False)}</td>'
     )
     # Usage.
-    if self.result.usage is not None:
+    if self.result.usage:
       s.write('<td>')
       self._render_summary_usage(s)
       s.write('</td>')

langfun/core/langfunc_test.py

@@ -87,7 +87,11 @@ class LangFuncCallTest(unittest.TestCase):
 
     r = l()
     self.assertEqual(
-        r, message.AIMessage('Hello!!!', score=0.0, logprobs=None, usage=None)
+        r,
+        message.AIMessage(
+            'Hello!!!', score=0.0, logprobs=None,
+            usage=language_model.UsageNotAvailable()
+        )
     )
     self.assertEqual(r.tags, ['lm-response', 'lm-output'])
     self.assertEqual(r.source, message.UserMessage('Hello'))
@@ -112,7 +116,11 @@ class LangFuncCallTest(unittest.TestCase):
       self.assertEqual(l.render(), 'Hello')
       r = l()
       self.assertEqual(
-          r, message.AIMessage('Hello!!!', score=0.0, logprobs=None, usage=None)
+          r,
+          message.AIMessage(
+              'Hello!!!', score=0.0, logprobs=None,
+              usage=language_model.UsageNotAvailable()
+          )
       )
       self.assertEqual(r.tags, ['lm-response', 'lm-output'])
 

langfun/core/language_model.py

@@ -14,10 +14,11 @@
 """Interface for language model."""
 
 import abc
+import contextlib
 import dataclasses
 import enum
 import time
-from typing import Annotated, Any, Callable, Sequence, Tuple, Type, Union
+from typing import Annotated, Any, Callable, Iterator, Sequence, Tuple, Type, Union
 from langfun.core import component
 from langfun.core import concurrent
 from langfun.core import console
@@ -84,6 +85,23 @@ class LMSamplingUsage(pg.Object):
   completion_tokens: int
   total_tokens: int
 
+  def __add__(self, other: 'LMSamplingUsage') -> 'LMSamplingUsage':
+    return LMSamplingUsage(
+        prompt_tokens=self.prompt_tokens + other.prompt_tokens,
+        completion_tokens=self.completion_tokens + other.completion_tokens,
+        total_tokens=self.total_tokens + other.total_tokens,
+    )
+
+
+class UsageNotAvailable(LMSamplingUsage):
+  """Usage information not available."""
+  prompt_tokens: pg.typing.Int(0).freeze()        # pytype: disable=invalid-annotation
+  completion_tokens: pg.typing.Int(0).freeze()   # pytype: disable=invalid-annotation
+  total_tokens: pg.typing.Int(0).freeze()        # pytype: disable=invalid-annotation
+
+  def __bool__(self) -> bool:
+    return False
+
 
 class LMSamplingResult(pg.Object):
   """Language model response."""
@@ -97,9 +115,9 @@ class LMSamplingResult(pg.Object):
   ] = []
 
   usage: Annotated[
-      LMSamplingUsage | None,
+      LMSamplingUsage,
       'Usage information. Currently only OpenAI models are supported.',
-  ] = None
+  ] = UsageNotAvailable()
 
 
 class LMSamplingOptions(component.Component):
@@ -398,7 +416,7 @@ class LanguageModel(component.Component):
           # which is accurate when n=1. For n > 1, we average the usage across
           # multiple samples.
           usage = result.usage
-          if len(result.samples) == 1 or usage is None:
+          if len(result.samples) == 1 or not usage:
             response.metadata.usage = usage
           else:
             n = len(result.samples)
@@ -408,6 +426,13 @@ class LanguageModel(component.Component):
                 total_tokens=usage.total_tokens // n,
             )
 
+          # Track usage.
+          trackers = component.context_value('__usage_trackers__', [])
+          if trackers:
+            model_id = self.model_id
+            for tracker in trackers:
+              tracker.track(model_id, usage)
+
           # Track the prompt for corresponding response.
           response.source = prompt
 
@@ -511,7 +536,7 @@ class LanguageModel(component.Component):
       prompt: message_lib.Message,
       response: message_lib.Message,
       call_counter: int,
-      usage: LMSamplingUsage | None,
+      usage: LMSamplingUsage,
       elapse: float,
   ) -> None:
     """Outputs debugging information."""
@@ -529,12 +554,13 @@ class LanguageModel(component.Component):
       self._debug_response(response, call_counter, usage, elapse)
 
   def _debug_model_info(
-      self, call_counter: int, usage: LMSamplingUsage | None) -> None:
+      self, call_counter: int, usage: LMSamplingUsage) -> None:
     """Outputs debugging information about the model."""
     title_suffix = ''
-    if usage and usage.total_tokens != 0:
+    if usage.total_tokens != 0:
       title_suffix = console.colored(
-          f' (total {usage.total_tokens} tokens)', 'red')
+          f' (total {usage.total_tokens} tokens)', 'red'
+      )
 
     console.write(
         self.format(compact=True, use_inferred=True),
@@ -546,11 +572,11 @@ class LanguageModel(component.Component):
       self,
       prompt: message_lib.Message,
       call_counter: int,
-      usage: LMSamplingUsage | None,
+      usage: LMSamplingUsage,
   ) -> None:
     """Outputs debugging information about the prompt."""
     title_suffix = ''
-    if usage and usage.prompt_tokens != 0:
+    if usage.prompt_tokens != 0:
       title_suffix = console.colored(f' ({usage.prompt_tokens} tokens)', 'red')
 
     console.write(
@@ -574,12 +600,12 @@ class LanguageModel(component.Component):
       self,
       response: message_lib.Message,
       call_counter: int,
-      usage: LMSamplingUsage | None,
+      usage: LMSamplingUsage,
       elapse: float
   ) -> None:
     """Outputs debugging information about the response."""
     title_suffix = ' ('
-    if usage and usage.completion_tokens != 0:
+    if usage.completion_tokens != 0:
       title_suffix += f'{usage.completion_tokens} tokens '
     title_suffix += f'in {elapse:.2f} seconds)'
     title_suffix = console.colored(title_suffix, 'red')
@@ -641,7 +667,7 @@ class LanguageModel(component.Component):
       debug = LMDebugMode.ALL if debug else LMDebugMode.NONE
 
     if debug & LMDebugMode.INFO:
-      self._debug_model_info(call_counter, None)
+      self._debug_model_info(call_counter, UsageNotAvailable())
 
     if debug & LMDebugMode.PROMPT:
       console.write(
@@ -692,3 +718,60 @@ class LanguageModel(component.Component):
       return max(int(requests_per_min / 60), 1)  # Max concurrency can't be zero
     else:
       return DEFAULT_MAX_CONCURRENCY  # Default of 1
+
+
+class _UsageTracker:
+  """Usage tracker."""
+
+  def __init__(self, model_ids: set[str] | None):
+    self.model_ids = model_ids
+    self.usages = {
+        m: LMSamplingUsage(0, 0, 0) for m in model_ids
+    } if model_ids else {}
+
+  def track(self, model_id: str, usage: LMSamplingUsage):
+    if self.model_ids is not None and model_id not in self.model_ids:
+      return
+    if not isinstance(usage, UsageNotAvailable) and model_id in self.usages:
+      self.usages[model_id] += usage
+    else:
+      self.usages[model_id] = usage
+
+
+@contextlib.contextmanager
+def track_usages(
+    *lm: Union[str, LanguageModel]
+) -> Iterator[dict[str, LMSamplingUsage]]:
+  """Context manager to track the usages of all language models in scope.
+
+  `lf.track_usages` works with threads spawned by `lf.concurrent_map` and
+  `lf.concurrent_execute`.
+
+  Example:
+    ```
+    lm = lf.llms.GeminiPro1()
+    with lf.track_usages() as usages:
+      # invoke any code that will call LLMs.
+
+    print(usages[lm.model_id])
+    ```
+
+  Args:
+    *lm: The language model(s) to track. If None, track all models in scope.
+
+  Yields:
+    A dictionary of model ID to usage. If a model does not supports usage
+    counting, the dict entry will be None.
+  """
+  if not lm:
+    model_ids = None
+  else:
+    model_ids = [m.model_id if isinstance(m, LanguageModel) else m for m in lm]
+
+  trackers = component.context_value('__usage_trackers__', [])
+  tracker = _UsageTracker(set(model_ids) if model_ids else None)
+  with component.context(__usage_trackers__=trackers + [tracker]):
+    try:
+      yield tracker.usages
+    finally:
+      pass

langfun/core/language_model_test.py

@@ -27,8 +27,8 @@ import pyglove as pg
 @pg.use_init_args(['failures_before_attempt'])
 class MockModel(lm_lib.LanguageModel):
   """A mock model that echo back user prompts."""
-
   failures_before_attempt: int = 0
+  name: str = 'MockModel'
 
   def _sample(self,
               prompts: list[message_lib.Message]
@@ -63,6 +63,10 @@ class MockModel(lm_lib.LanguageModel):
         retry_interval=1,
     )(prompts)
 
+  @property
+  def model_id(self) -> str:
+    return self.name
+
 
 class MockScoringModel(MockModel):
 
@@ -580,6 +584,34 @@ class LanguageModelTest(unittest.TestCase):
     self.assertEqual(lm.rate_to_max_concurrency(requests_per_min=1), 1)
     self.assertEqual(lm.rate_to_max_concurrency(tokens_per_min=1), 1)
 
+  def test_track_usages(self):
+    lm = MockModel(name='model1')
+    lm2 = MockModel(name='model2')
+    with lm_lib.track_usages() as usages1:
+      _ = lm('hi')
+      with lm_lib.track_usages(lm2) as usages2:
+        with lm_lib.track_usages('model1') as usages3:
+          with lm_lib.track_usages('model1', lm2) as usages4:
+            def call_lm(prompt):
+              _ = lm.sample([prompt] * 2)
+            lm2('hi')
+            list(concurrent.concurrent_map(call_lm, ['hi', 'hello']))
+
+    self.assertEqual(usages2, {
+        'model2': lm_lib.LMSamplingUsage(100, 100, 200),
+    })
+    self.assertEqual(usages3, {
+        'model1': lm_lib.LMSamplingUsage(100 * 4, 100 * 4, 200 * 4),
+    })
+    self.assertEqual(usages4, {
+        'model1': lm_lib.LMSamplingUsage(100 * 4, 100 * 4, 200 * 4),
+        'model2': lm_lib.LMSamplingUsage(100, 100, 200),
+    })
+    self.assertEqual(usages1, {
+        'model1': lm_lib.LMSamplingUsage(100 * 5, 100 * 5, 200 * 5),
+        'model2': lm_lib.LMSamplingUsage(100, 100, 200),
+    })
+
 
 if __name__ == '__main__':
   unittest.main()

langfun/core/llms/openai.py

@@ -202,15 +202,14 @@ class OpenAI(lf.LanguageModel):
             lf.LMSample(choice.text.strip(), score=choice.logprobs or 0.0)
         )
 
+      n = len(samples_by_index)
       usage = lf.LMSamplingUsage(
-          prompt_tokens=response.usage.prompt_tokens,
-          completion_tokens=response.usage.completion_tokens,
-          total_tokens=response.usage.total_tokens,
+          prompt_tokens=response.usage.prompt_tokens // n,
+          completion_tokens=response.usage.completion_tokens // n,
+          total_tokens=response.usage.total_tokens // n,
       )
       return [
-          lf.LMSamplingResult(
-              samples_by_index[index], usage=usage if index == 0 else None
-          )
+          lf.LMSamplingResult(samples_by_index[index], usage=usage)
           for index in sorted(samples_by_index.keys())
       ]
 

langfun/core/llms/openai_test.py

@@ -191,9 +191,9 @@ class OpenAITest(unittest.TestCase):
                         score=0.0,
                         logprobs=None,
                         usage=lf.LMSamplingUsage(
-                            prompt_tokens=33,
-                            completion_tokens=33,
-                            total_tokens=66
+                            prompt_tokens=16,
+                            completion_tokens=16,
+                            total_tokens=33
                         ),
                         tags=[lf.Message.TAG_LM_RESPONSE],
                     ),
@@ -206,9 +206,9 @@ class OpenAITest(unittest.TestCase):
                         score=0.1,
                         logprobs=None,
                         usage=lf.LMSamplingUsage(
-                            prompt_tokens=33,
-                            completion_tokens=33,
-                            total_tokens=66
+                            prompt_tokens=16,
+                            completion_tokens=16,
+                            total_tokens=33
                         ),
                         tags=[lf.Message.TAG_LM_RESPONSE],
                     ),
@@ -221,9 +221,9 @@ class OpenAITest(unittest.TestCase):
                         score=0.2,
                         logprobs=None,
                         usage=lf.LMSamplingUsage(
-                            prompt_tokens=33,
-                            completion_tokens=33,
-                            total_tokens=66
+                            prompt_tokens=16,
+                            completion_tokens=16,
+                            total_tokens=33
                         ),
                         tags=[lf.Message.TAG_LM_RESPONSE],
                     ),
@@ -232,7 +232,7 @@ class OpenAITest(unittest.TestCase):
                 ),
             ],
             usage=lf.LMSamplingUsage(
-                prompt_tokens=100, completion_tokens=100, total_tokens=200
+                prompt_tokens=50, completion_tokens=50, total_tokens=100
             ),
         ),
     )
@@ -245,7 +245,11 @@ class OpenAITest(unittest.TestCase):
                         'Sample 0 for prompt 1.',
                         score=0.0,
                         logprobs=None,
-                        usage=None,
+                        usage=lf.LMSamplingUsage(
+                            prompt_tokens=16,
+                            completion_tokens=16,
+                            total_tokens=33
+                        ),
                         tags=[lf.Message.TAG_LM_RESPONSE],
                     ),
                     score=0.0,
@@ -256,7 +260,11 @@ class OpenAITest(unittest.TestCase):
                         'Sample 1 for prompt 1.',
                         score=0.1,
                         logprobs=None,
-                        usage=None,
+                        usage=lf.LMSamplingUsage(
+                            prompt_tokens=16,
+                            completion_tokens=16,
+                            total_tokens=33
+                        ),
                         tags=[lf.Message.TAG_LM_RESPONSE],
                     ),
                     score=0.1,
@@ -267,13 +275,20 @@ class OpenAITest(unittest.TestCase):
                         'Sample 2 for prompt 1.',
                         score=0.2,
                         logprobs=None,
-                        usage=None,
+                        usage=lf.LMSamplingUsage(
+                            prompt_tokens=16,
+                            completion_tokens=16,
+                            total_tokens=33
+                        ),
                         tags=[lf.Message.TAG_LM_RESPONSE],
                     ),
                     score=0.2,
                     logprobs=None,
                 ),
             ],
+            usage=lf.LMSamplingUsage(
+                prompt_tokens=50, completion_tokens=50, total_tokens=100
+            ),
         ),
     )
 

langfun/core/llms/rest_test.py

@@ -89,7 +89,7 @@ class RestTest(unittest.TestCase):
               "max_tokens=4096, stop=['\\n']."
           ),
       )
-      self.assertIsNone(response.usage)
+      self.assertEqual(response.usage, lf.UsageNotAvailable())
 
   def test_call_errors(self):
     for status_code, error_type, error_message in [

langfun/core/logging.py

@@ -0,0 +1,168 @@
+# Copyright 2024 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.
+"""Langfun event logging."""
+
+import datetime
+import io
+import typing
+from typing import Any, Literal, ContextManager
+
+from langfun.core import console
+import pyglove as pg
+
+
+LogLevel = Literal['debug', 'info', 'error', 'warning', 'fatal']
+_LOG_LEVELS = list(typing.get_args(LogLevel))
+_TLS_KEY_MIN_LOG_LEVEL = '_event_log_level'
+
+
+def use_log_level(log_level: LogLevel | None = 'info') -> ContextManager[None]:
+  """Contextmanager to enable logging at a given level."""
+  return pg.object_utils.thread_local_value_scope(
+      _TLS_KEY_MIN_LOG_LEVEL, log_level, 'info')
+
+
+def get_log_level() -> LogLevel | None:
+  """Gets the current minimum log level."""
+  return pg.object_utils.thread_local_get(_TLS_KEY_MIN_LOG_LEVEL, 'info')
+
+
+class LogEntry(pg.Object):
+  """Event log entry."""
+  time: datetime.datetime
+  level: LogLevel
+  message: str
+  metadata: dict[str, Any] = pg.Dict()
+  indent: int = 0
+
+  def should_output(self, min_log_level: LogLevel) -> bool:
+    return _LOG_LEVELS.index(self.level) >= _LOG_LEVELS.index(min_log_level)
+
+  def _repr_html_(self) -> str:
+    s = io.StringIO()
+    padding_left = 50 * self.indent
+    s.write(f'<div style="padding-left: {padding_left}px;">')
+    s.write(self._message_display)
+    if self.metadata:
+      s.write('<div style="padding-left: 20px; margin-top: 10px">')
+      s.write('<table style="border-top: 1px solid #EEEEEE;">')
+      for k, v in self.metadata.items():
+        if hasattr(v, '_repr_html_'):
+          cs = v._repr_html_()  # pylint: disable=protected-access
+        else:
+          cs = f'<span style="white-space: pre-wrap">{str(v)}</span>'
+        key_span = self._round_text(k, color='#F1C40F', margin_bottom='0px')
+        s.write(
+            '<tr>'
+            '<td style="padding: 5px; vertical-align: top; '
+            f'border-bottom: 1px solid #EEEEEE">{key_span}</td>'
+            '<td style="padding: 5px; vertical-align: top; '
+            f'border-bottom: 1px solid #EEEEEE">{cs}</td></tr>'
+        )
+      s.write('</table></div>')
+    return s.getvalue()
+
+  @property
+  def _message_text_color(self) -> str:
+    match self.level:
+      case 'debug':
+        return '#EEEEEE'
+      case 'info':
+        return '#A3E4D7'
+      case 'error':
+        return '#F5C6CB'
+      case 'fatal':
+        return '#F19CBB'
+      case _:
+        raise ValueError(f'Unknown log level: {self.level}')
+
+  @property
+  def _time_display(self) -> str:
+    display_text = self.time.strftime('%H:%M:%S')
+    alt_text = self.time.strftime('%Y-%m-%d %H:%M:%S.%f')
+    return (
+        '<span style="background-color: #BBBBBB; color: white; '
+        'border-radius:5px; padding:0px 5px 0px 5px;" '
+        f'title="{alt_text}">{display_text}</span>'
+    )
+
+  @property
+  def _message_display(self) -> str:
+    return self._round_text(
+        self._time_display + '&nbsp;' + self.message,
+        color=self._message_text_color,
+    )
+
+  def _round_text(
+      self,
+      text: str,
+      *,
+      color: str = '#EEEEEE',
+      display: str = 'inline-block',
+      margin_top: str = '5px',
+      margin_bottom: str = '5px',
+      whitespace: str = 'pre-wrap') -> str:
+    return (
+        f'<span style="background:{color}; display:{display};'
+        f'border-radius:10px; padding:5px; '
+        f'margin-top: {margin_top}; margin-bottom: {margin_bottom}; '
+        f'white-space: {whitespace}">{text}</span>'
+    )
+
+
+def log(level: LogLevel,
+        message: str,
+        *,
+        indent: int = 0,
+        **kwargs) -> LogEntry:
+  """Logs a message."""
+  entry = LogEntry(
+      indent=indent,
+      level=level,
+      time=datetime.datetime.now(),
+      message=message,
+      metadata=kwargs,
+  )
+  if entry.should_output(get_log_level()):
+    if console.under_notebook():
+      console.display(entry)
+    else:
+      # TODO(daiyip): Improve the console output formatting.
+      console.write(entry)
+  return entry
+
+
+def debug(message: str, *, indent: int = 0, **kwargs) -> LogEntry:
+  """Logs a debug message to the session."""
+  return log('debug', message, indent=indent, **kwargs)
+
+
+def info(message: str, *, indent: int = 0, **kwargs) -> LogEntry:
+  """Logs an info message to the session."""
+  return log('info', message, indent=indent, **kwargs)
+
+
+def warning(message: str, *, indent: int = 0, **kwargs) -> LogEntry:
+  """Logs an info message to the session."""
+  return log('warning', message, indent=indent, **kwargs)
+
+
+def error(message: str, *, indent: int = 0, **kwargs) -> LogEntry:
+  """Logs an error message to the session."""
+  return log('error', message, indent=indent, **kwargs)
+
+
+def fatal(message: str, *, indent: int = 0, **kwargs) -> LogEntry:
+  """Logs a fatal message to the session."""
+  return log('fatal', message, indent=indent, **kwargs)