langfun 0.0.2.dev20240330__py3-none-any.whl → 0.0.2.dev20240511__py3-none-any.whl

langfun/core/llms/anthropic.py

@@ -0,0 +1,263 @@
+# Copyright 2023 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.
+"""Language models from Anthropic."""
+
+import base64
+import functools
+import os
+from typing import Annotated, Any
+
+import langfun.core as lf
+from langfun.core import modalities as lf_modalities
+import pyglove as pg
+import requests
+
+
+SUPPORTED_MODELS_AND_SETTINGS = {
+    # See https://docs.anthropic.com/claude/docs/models-overview
+    # Rate limits from https://docs.anthropic.com/claude/reference/rate-limits
+    #     RPM/TPM for Claude-2.1, Claude-2.0, and Claude-Instant-1.2 estimated
+    #     as RPM/TPM of the largest-available model (Claude-3-Opus).
+    'claude-3-opus-20240229': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
+    'claude-3-sonnet-20240229': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
+    'claude-3-haiku-20240307': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
+    'claude-2.1': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
+    'claude-2.0': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
+    'claude-instant-1.2': pg.Dict(max_tokens=4096, rpm=4000, tpm=400000),
+}
+
+
+class AnthropicError(Exception):  # pylint: disable=g-bad-exception-name
+  """Base class for Anthropic errors."""
+
+
+class RateLimitError(AnthropicError):
+  """Error for rate limit reached."""
+
+
+class OverloadedError(AnthropicError):
+  """Anthropic's server is temporarily overloaded."""
+
+
+_ANTHROPIC_MESSAGE_API_ENDPOINT = 'https://api.anthropic.com/v1/messages'
+_ANTHROPIC_API_VERSION = '2023-06-01'
+
+
+@lf.use_init_args(['model'])
+class Anthropic(lf.LanguageModel):
+  """Anthropic LLMs (Claude) through REST APIs.
+
+  See https://docs.anthropic.com/claude/reference/messages_post
+  """
+
+  model: pg.typing.Annotated[
+      pg.typing.Enum(
+          pg.MISSING_VALUE, list(SUPPORTED_MODELS_AND_SETTINGS.keys())
+      ),
+      'The name of the model to use.',
+  ]
+
+  multimodal: Annotated[bool, 'Whether this model has multimodal support.'] = (
+      True
+  )
+
+  api_key: Annotated[
+      str | None,
+      (
+          'API key. If None, the key will be read from environment variable '
+          "'ANTHROPIC_API_KEY'."
+      ),
+  ] = None
+
+  def _on_bound(self):
+    super()._on_bound()
+    self._api_key = None
+    self.__dict__.pop('_api_initialized', None)
+    self.__dict__.pop('_session', None)
+
+  @functools.cached_property
+  def _api_initialized(self):
+    api_key = self.api_key or os.environ.get('ANTHROPIC_API_KEY', None)
+    if not api_key:
+      raise ValueError(
+          'Please specify `api_key` during `__init__` or set environment '
+          'variable `ANTHROPIC_API_KEY` with your Anthropic API key.'
+      )
+    self._api_key = api_key
+    return True
+
+  @functools.cached_property
+  def _session(self) -> requests.Session:
+    assert self._api_initialized
+    s = requests.Session()
+    s.headers.update({
+        'x-api-key': self._api_key,
+        'anthropic-version': _ANTHROPIC_API_VERSION,
+        'content-type': 'application/json',
+    })
+    return s
+
+  @property
+  def model_id(self) -> str:
+    """Returns a string to identify the model."""
+    return self.model
+
+  @property
+  def max_concurrency(self) -> int:
+    rpm = SUPPORTED_MODELS_AND_SETTINGS[self.model].get('rpm', 0)
+    tpm = SUPPORTED_MODELS_AND_SETTINGS[self.model].get('tpm', 0)
+    return self.rate_to_max_concurrency(
+        requests_per_min=rpm, tokens_per_min=tpm
+    )
+
+  def _sample(self, prompts: list[lf.Message]) -> list[lf.LMSamplingResult]:
+    assert self._api_initialized
+    return self._parallel_execute_with_currency_control(
+        self._sample_single, prompts, retry_on_errors=(RateLimitError)
+    )
+
+  def _get_request_args(self, options: lf.LMSamplingOptions) -> dict[str, Any]:
+    """Returns a dict as request arguments."""
+    # Authropic requires `max_tokens` to be specified.
+    max_tokens = (
+        options.max_tokens
+        or SUPPORTED_MODELS_AND_SETTINGS[self.model].max_tokens
+    )
+    args = dict(
+        model=self.model,
+        max_tokens=max_tokens,
+        stream=False,
+    )
+    if options.stop:
+      args['stop_sequences'] = options.stop
+    if options.temperature is not None:
+      args['temperature'] = options.temperature
+    if options.top_k is not None:
+      args['top_k'] = options.top_k
+    if options.top_p is not None:
+      args['top_p'] = options.top_p
+    return args
+
+  def _content_from_message(self, prompt: lf.Message) -> list[dict[str, Any]]:
+    """Converts an message to Anthropic's content protocol (list of dicts)."""
+    # Refer: https://docs.anthropic.com/claude/reference/messages-examples
+    if self.multimodal:
+      content = []
+      for chunk in prompt.chunk():
+        if isinstance(chunk, str):
+          item = dict(type='text', text=chunk)
+        elif isinstance(chunk, lf_modalities.Image):
+          # NOTE(daiyip): Anthropic only support image content instead of URL.
+          item = dict(
+              type='image',
+              source=dict(
+                  type='base64',
+                  media_type=chunk.mime_type,
+                  data=base64.b64encode(chunk.to_bytes()).decode(),
+              ),
+          )
+        else:
+          raise ValueError(f'Unsupported modality object: {chunk!r}.')
+        content.append(item)
+      return content
+    else:
+      return [dict(type='text', text=prompt.text)]
+
+  def _message_from_content(self, content: list[dict[str, Any]]) -> lf.Message:
+    """Converts Anthropic's content protocol to message."""
+    # Refer: https://docs.anthropic.com/claude/reference/messages-examples
+    return lf.AIMessage.from_chunks(
+        [x['text'] for x in content if x['type'] == 'text']
+    )
+
+  def _parse_response(self, response: requests.Response) -> lf.LMSamplingResult:
+    """Parses Anthropic's response."""
+    # NOTE(daiyip): Refer https://docs.anthropic.com/claude/reference/errors
+    if response.status_code == 200:
+      output = response.json()
+      message = self._message_from_content(output['content'])
+      input_tokens = output['usage']['input_tokens']
+      output_tokens = output['usage']['output_tokens']
+      return lf.LMSamplingResult(
+          [lf.LMSample(message)],
+          usage=lf.LMSamplingUsage(
+              prompt_tokens=input_tokens,
+              completion_tokens=output_tokens,
+              total_tokens=input_tokens + output_tokens,
+          ),
+      )
+    else:
+      if response.status_code == 429:
+        error_cls = RateLimitError
+      elif response.status_code in (502, 529):
+        error_cls = OverloadedError
+      else:
+        error_cls = AnthropicError
+      raise error_cls(f'{response.status_code}: {response.content}')
+
+  def _sample_single(self, prompt: lf.Message) -> lf.LMSamplingResult:
+    request = dict()
+    request.update(self._get_request_args(self.sampling_options))
+    request.update(
+        dict(
+            messages=[
+                dict(role='user', content=self._content_from_message(prompt))
+            ]
+        )
+    )
+    try:
+      response = self._session.post(
+          _ANTHROPIC_MESSAGE_API_ENDPOINT, json=request, timeout=self.timeout,
+      )
+      return self._parse_response(response)
+    except ConnectionError as e:
+      raise OverloadedError(str(e)) from e
+
+
+class Claude3(Anthropic):
+  """Base class for Claude 3 models. 200K input tokens and 4K output tokens."""
+  multimodal = True
+
+
+class Claude3Opus(Claude3):
+  """Anthropic's most powerful model."""
+
+  model = 'claude-3-opus-20240229'
+
+
+class Claude3Sonnet(Claude3):
+  """A balance between between Opus and Haiku."""
+
+  model = 'claude-3-sonnet-20240229'
+
+
+class Claude3Haiku(Claude3):
+  """Anthropic's most compact model."""
+
+  model = 'claude-3-haiku-20240307'
+
+
+class Claude2(Anthropic):
+  """Predecessor to Claude 3 with 100K context window.."""
+  model = 'claude-2.0'
+
+
+class Claude21(Anthropic):
+  """Updated Claude 2 model with improved accuracy and 200K context window."""
+  model = 'claude-2.1'
+
+
+class ClaudeInstant(Anthropic):
+  """Cheapest small and fast model, 100K context window."""
+  model = 'claude-instant-1.2'

langfun/core/llms/anthropic_test.py

@@ -0,0 +1,167 @@
+# Copyright 2023 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 Anthropic models."""
+
+import base64
+import os
+from typing import Any
+import unittest
+from unittest import mock
+from langfun.core import modalities as lf_modalities
+from langfun.core.llms import anthropic
+import pyglove as pg
+import requests
+
+
+def mock_requests_post(url: str, json: dict[str, Any], **kwargs):
+  del url, kwargs
+
+  response = requests.Response()
+  response.status_code = 200
+  response._content = pg.to_json_str({
+      'content': [{
+          'type': 'text',
+          'text': (
+              f'hello with temperature={json.get("temperature")}, '
+              f'top_k={json.get("top_k")}, '
+              f'top_p={json.get("top_p")}, '
+              f'max_tokens={json.get("max_tokens")}, '
+              f'stop={json.get("stop_sequences")}.'
+          ),
+      }],
+      'usage': {
+          'input_tokens': 2,
+          'output_tokens': 1,
+      },
+  }).encode()
+  return response
+
+
+image_content = (
+    b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x18\x00\x00\x00\x18\x04'
+    b'\x03\x00\x00\x00\x12Y \xcb\x00\x00\x00\x18PLTE\x00\x00'
+    b'\x00fff_chaag_cg_ch^ci_ciC\xedb\x94\x00\x00\x00\x08tRNS'
+    b'\x00\n\x9f*\xd4\xff_\xf4\xe4\x8b\xf3a\x00\x00\x00>IDATx'
+    b'\x01c \x05\x08)"\xd8\xcc\xae!\x06pNz\x88k\x19\\Q\xa8"\x10'
+    b'\xc1\x14\x95\x01%\xc1\n\xa143Ta\xa8"D-\x84\x03QM\x98\xc3'
+    b'\x1a\x1a\x1a@5\x0e\x04\xa0q\x88\x05\x00\x07\xf8\x18\xf9'
+    b'\xdao\xd0|\x00\x00\x00\x00IEND\xaeB`\x82'
+)
+
+
+def mock_mm_requests_post(url: str, json: dict[str, Any], **kwargs):
+  del url, kwargs
+  v = json['messages'][0]['content'][0]
+  image = lf_modalities.Image.from_bytes(base64.b64decode(v['source']['data']))
+
+  response = requests.Response()
+  response.status_code = 200
+  response._content = pg.to_json_str({
+      'content': [{
+          'type': 'text',
+          'text': f'{v["type"]}: {image.mime_type}',
+      }],
+      'usage': {
+          'input_tokens': 2,
+          'output_tokens': 1,
+      },
+  }).encode()
+  return response
+
+
+def mock_requests_post_error(status_code, error_type, error_message):
+  def _mock_requests(url: str, json: dict[str, Any], **kwargs):
+    del url, json, kwargs
+    response = requests.Response()
+    response.status_code = status_code
+    response._content = pg.to_json_str(
+        {
+            'error': {
+                'type': error_type,
+                'message': error_message,
+            }
+        }
+    ).encode()
+    return response
+
+  return _mock_requests
+
+
+class AnthropicTest(unittest.TestCase):
+
+  def test_basics(self):
+    self.assertEqual(
+        anthropic.Claude3Haiku().model_id, 'claude-3-haiku-20240307'
+    )
+    self.assertGreater(anthropic.Claude3Haiku().max_concurrency, 0)
+
+  def test_api_key(self):
+    lm = anthropic.Claude3Haiku()
+    with self.assertRaisesRegex(ValueError, 'Please specify `api_key`'):
+      lm('hi')
+
+    with mock.patch('requests.Session.post') as mock_request:
+      mock_request.side_effect = mock_requests_post
+
+      lm = anthropic.Claude3Haiku(api_key='fake key')
+      self.assertRegex(lm('hi').text, 'hello.*')
+
+      os.environ['ANTHROPIC_API_KEY'] = 'abc'
+      lm = anthropic.Claude3Haiku()
+      self.assertRegex(lm('hi').text, 'hello.*')
+      del os.environ['ANTHROPIC_API_KEY']
+
+  def test_call(self):
+    with mock.patch('requests.Session.post') as mock_request:
+      mock_request.side_effect = mock_requests_post
+      lm = anthropic.Claude3Haiku(api_key='fake_key')
+      response = lm('hello', temperature=0.0, top_k=0.1, top_p=0.2, stop=['\n'])
+      self.assertEqual(
+          response.text,
+          (
+              'hello with temperature=0.0, top_k=0.1, top_p=0.2, '
+              "max_tokens=4096, stop=['\\n']."
+          ),
+      )
+      self.assertIsNotNone(response.usage)
+      self.assertIsNotNone(response.usage.prompt_tokens, 2)
+      self.assertIsNotNone(response.usage.completion_tokens, 1)
+      self.assertIsNotNone(response.usage.total_tokens, 3)
+
+  def test_mm_call(self):
+    with mock.patch('requests.Session.post') as mock_mm_request:
+      mock_mm_request.side_effect = mock_mm_requests_post
+      lm = anthropic.Claude3Haiku(api_key='fake_key')
+      response = lm(lf_modalities.Image.from_bytes(image_content), lm=lm)
+      self.assertEqual(response.text, 'image: image/png')
+
+  def test_call_errors(self):
+    for status_code, error_type, error_message in [
+        (429, 'rate_limit', 'Rate limit exceeded.'),
+        (529, 'service_unavailable', 'Service unavailable.'),
+        (500, 'bad_request', 'Bad request.'),
+    ]:
+      with mock.patch('requests.Session.post') as mock_mm_request:
+        mock_mm_request.side_effect = mock_requests_post_error(
+            status_code, error_type, error_message
+        )
+        lm = anthropic.Claude3Haiku(api_key='fake_key')
+        with self.assertRaisesRegex(
+            Exception, f'.*{status_code}: .*{error_message}'
+        ):
+          lm('hello', lm=lm, max_attempts=1)
+
+
+if __name__ == '__main__':
+  unittest.main()

langfun/core/llms/cache/in_memory_test.py

@@ -44,28 +44,37 @@ class InMemoryLMCacheTest(unittest.TestCase):
     self.assertEqual(
         list(cache.keys()),
         [
-            ('a', (0.0, 1024, 1, 40, None, None), 0),
-            ('a', (0.0, 1024, 1, 40, None, None), 1),
-            ('b', (0.0, 1024, 1, 40, None, None), 0),
-            ('c', (0.0, 1024, 1, 40, None, None), 0),
+            ('a', (None, None, 1, 40, None, None), 0),
+            ('a', (None, None, 1, 40, None, None), 1),
+            ('b', (None, None, 1, 40, None, None), 0),
+            ('c', (None, None, 1, 40, None, None), 0),
         ],
     )
     self.assertEqual(
         list(cache.keys('StaticSequence')),
         [
-            ('a', (0.0, 1024, 1, 40, None, None), 0),
-            ('a', (0.0, 1024, 1, 40, None, None), 1),
-            ('b', (0.0, 1024, 1, 40, None, None), 0),
-            ('c', (0.0, 1024, 1, 40, None, None), 0),
+            ('a', (None, None, 1, 40, None, None), 0),
+            ('a', (None, None, 1, 40, None, None), 1),
+            ('b', (None, None, 1, 40, None, None), 0),
+            ('c', (None, None, 1, 40, None, None), 0),
         ],
     )
 
     def cache_entry(response_text, cache_seed=0):
       return base.LMCacheEntry(
-          lf.LMSamplingResult([
-              lf.LMSample(
-                  lf.AIMessage(response_text, cache_seed=cache_seed), score=1.0)
-          ])
+          lf.LMSamplingResult(
+              [
+                  lf.LMSample(
+                      lf.AIMessage(response_text, cache_seed=cache_seed),
+                      score=1.0
+                  )
+              ],
+              usage=lf.LMSamplingUsage(
+                  1,
+                  len(response_text),
+                  len(response_text) + 1,
+              )
+          )
       )
 
     self.assertEqual(
@@ -90,19 +99,19 @@ class InMemoryLMCacheTest(unittest.TestCase):
         list(cache.items()),
         [
             (
-                ('a', (0.0, 1024, 1, 40, None, None), 0),
+                ('a', (None, None, 1, 40, None, None), 0),
                 cache_entry('1'),
             ),
             (
-                ('a', (0.0, 1024, 1, 40, None, None), 1),
+                ('a', (None, None, 1, 40, None, None), 1),
                 cache_entry('2', 1),
             ),
             (
-                ('b', (0.0, 1024, 1, 40, None, None), 0),
+                ('b', (None, None, 1, 40, None, None), 0),
                 cache_entry('3'),
             ),
             (
-                ('c', (0.0, 1024, 1, 40, None, None), 0),
+                ('c', (None, None, 1, 40, None, None), 0),
                 cache_entry('4'),
             ),
         ],
@@ -111,19 +120,19 @@ class InMemoryLMCacheTest(unittest.TestCase):
         list(cache.items('StaticSequence')),
         [
             (
-                ('a', (0.0, 1024, 1, 40, None, None), 0),
+                ('a', (None, None, 1, 40, None, None), 0),
                 cache_entry('1'),
             ),
             (
-                ('a', (0.0, 1024, 1, 40, None, None), 1),
+                ('a', (None, None, 1, 40, None, None), 1),
                 cache_entry('2', 1),
             ),
             (
-                ('b', (0.0, 1024, 1, 40, None, None), 0),
+                ('b', (None, None, 1, 40, None, None), 0),
                 cache_entry('3'),
             ),
             (
-                ('c', (0.0, 1024, 1, 40, None, None), 0),
+                ('c', (None, None, 1, 40, None, None), 0),
                 cache_entry('4'),
             ),
         ],
@@ -161,15 +170,15 @@ class InMemoryLMCacheTest(unittest.TestCase):
     self.assertEqual(
         list(cache.keys()),
         [
-            ('a', (0.0, 1024, 1, 40, None, None), 0),
-            ('a', (1.0, 1024, 1, 40, None, None), 0),
+            ('a', (None, None, 1, 40, None, None), 0),
+            ('a', (1.0, None, 1, 40, None, None), 0),
         ],
     )
 
   def test_different_model(self):
     cache = in_memory.InMemory()
-    lm1 = fake.StaticSequence(['1', '2', '3'], cache=cache)
-    lm2 = fake.Echo(cache=cache)
+    lm1 = fake.StaticSequence(['1', '2', '3'], cache=cache, temperature=0.0)
+    lm2 = fake.Echo(cache=cache, temperature=0.0)
 
     self.assertEqual(lm1('a'), '1')
     self.assertEqual(lm2('a'), 'a')
@@ -180,15 +189,15 @@ class InMemoryLMCacheTest(unittest.TestCase):
     self.assertEqual(
         list(cache.keys('StaticSequence')),
         [
-            ('a', (0.0, 1024, 1, 40, None, None), 0),
-            ('b', (0.0, 1024, 1, 40, None, None), 0),
+            ('a', (0.0, None, 1, 40, None, None), 0),
+            ('b', (0.0, None, 1, 40, None, None), 0),
         ],
     )
     self.assertEqual(
         list(cache.keys('Echo')),
         [
-            ('a', (0.0, 1024, 1, 40, None, None), 0),
-            ('b', (0.0, 1024, 1, 40, None, None), 0),
+            ('a', (0.0, None, 1, 40, None, None), 0),
+            ('b', (0.0, None, 1, 40, None, None), 0),
         ],
     )
     self.assertEqual(len(cache), 4)

langfun/core/llms/fake.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 """Fake LMs for testing."""
 
+import abc
 from typing import Annotated
 import langfun.core as lf
 
@@ -23,15 +24,32 @@ class Fake(lf.LanguageModel):
   def _score(self, prompt: lf.Message, completions: list[lf.Message]):
     return [lf.LMScoringResult(score=-i * 1.0) for i in range(len(completions))]
 
+  def _sample(self, prompts: list[lf.Message]) -> list[lf.LMSamplingResult]:
+    results = []
+    for prompt in prompts:
+      response = self._response_from(prompt)
+      results.append(
+          lf.LMSamplingResult(
+              [lf.LMSample(response, 1.0)],
+              usage=lf.LMSamplingUsage(
+                  prompt_tokens=len(prompt.text),
+                  completion_tokens=len(response.text),
+                  total_tokens=len(prompt.text) + len(response.text),
+              )
+          )
+      )
+    return results
+
+  @abc.abstractmethod
+  def _response_from(self, prompt: lf.Message) -> lf.Message:
+    """Returns the response for the given prompt."""
+
 
 class Echo(Fake):
   """A simple echo language model for testing."""
 
-  def _sample(self, prompts: list[lf.Message]) -> list[lf.LMSamplingResult]:
-    return [
-        lf.LMSamplingResult([lf.LMSample(prompt.text, 1.0)])
-        for prompt in prompts
-    ]
+  def _response_from(self, prompt: lf.Message) -> lf.Message:
+    return lf.AIMessage(prompt.text)
 
 
 @lf.use_init_args(['response'])
@@ -39,15 +57,12 @@ class StaticResponse(Fake):
   """Language model that always gives the same canned response."""
 
   response: Annotated[
-      str,
+      str | lf.Message,
       'A canned response that will be returned regardless of the prompt.'
   ]
 
-  def _sample(self, prompts: list[lf.Message]) -> list[lf.LMSamplingResult]:
-    return [
-        lf.LMSamplingResult([lf.LMSample(self.response, 1.0)])
-        for _ in prompts
-    ]
+  def _response_from(self, prompt: lf.Message) -> lf.Message:
+    return lf.AIMessage.from_value(self.response)
 
 
 @lf.use_init_args(['mapping'])
@@ -55,15 +70,12 @@ class StaticMapping(Fake):
   """A static mapping from prompt to response."""
 
   mapping: Annotated[
-      dict[str, str],
+      dict[str, str | lf.Message],
       'A mapping from prompt to response.'
   ]
 
-  def _sample(self, prompts: list[str]) -> list[lf.LMSamplingResult]:
-    return [
-        lf.LMSamplingResult([lf.LMSample(self.mapping[prompt], 1.0)])
-        for prompt in prompts
-    ]
+  def _response_from(self, prompt: lf.Message) -> lf.Message:
+    return lf.AIMessage.from_value(self.mapping[prompt])
 
 
 @lf.use_init_args(['sequence'])
@@ -71,7 +83,7 @@ class StaticSequence(Fake):
   """A static sequence of responses to use."""
 
   sequence: Annotated[
-      list[str],
+      list[str | lf.Message],
       'A sequence of strings as the response.'
   ]
 
@@ -79,10 +91,7 @@ class StaticSequence(Fake):
     super()._on_bound()
     self._pos = 0
 
-  def _sample(self, prompts: list[str]) -> list[lf.LMSamplingResult]:
-    results = []
-    for _ in prompts:
-      results.append(lf.LMSamplingResult(
-          [lf.LMSample(self.sequence[self._pos], 1.0)]))
-      self._pos += 1
-    return results
+  def _response_from(self, prompt: lf.Message) -> lf.Message:
+    r = lf.AIMessage.from_value(self.sequence[self._pos])
+    self._pos += 1
+    return r