langfun 0.0.2.dev20240429__py3-none-any.whl → 0.1.2.dev202501140804__py3-none-any.whl

langfun/core/llms/__init__.py

@@ -24,35 +24,88 @@ from langfun.core.llms.fake import StaticMapping
 from langfun.core.llms.fake import StaticResponse
 from langfun.core.llms.fake import StaticSequence
 
+# Compositional models.
+from langfun.core.llms.compositional import RandomChoice
+
+# REST-based models.
+from langfun.core.llms.rest import REST
+
 # Gemini models.
 from langfun.core.llms.google_genai import GenAI
-from langfun.core.llms.google_genai import GeminiPro
-from langfun.core.llms.google_genai import GeminiProVision
-from langfun.core.llms.google_genai import Palm2
-from langfun.core.llms.google_genai import Palm2_IT
+from langfun.core.llms.google_genai import GeminiFlash2_0ThinkingExp_20241219
+from langfun.core.llms.google_genai import GeminiFlash2_0Exp
+from langfun.core.llms.google_genai import GeminiExp_20241206
+from langfun.core.llms.google_genai import GeminiExp_20241114
+from langfun.core.llms.google_genai import GeminiPro1_5
+from langfun.core.llms.google_genai import GeminiPro1_5_002
+from langfun.core.llms.google_genai import GeminiPro1_5_001
+from langfun.core.llms.google_genai import GeminiFlash1_5
+from langfun.core.llms.google_genai import GeminiFlash1_5_002
+from langfun.core.llms.google_genai import GeminiFlash1_5_001
+from langfun.core.llms.google_genai import GeminiPro1
+
+from langfun.core.llms.vertexai import VertexAI
+from langfun.core.llms.vertexai import VertexAIGeminiFlash2_0ThinkingExp_20241219
+from langfun.core.llms.vertexai import VertexAIGeminiFlash2_0Exp
+from langfun.core.llms.vertexai import VertexAIGeminiExp_20241206
+from langfun.core.llms.vertexai import VertexAIGeminiExp_20241114
+from langfun.core.llms.vertexai import VertexAIGeminiPro1_5
+from langfun.core.llms.vertexai import VertexAIGeminiPro1_5_002
+from langfun.core.llms.vertexai import VertexAIGeminiPro1_5_001
+from langfun.core.llms.vertexai import VertexAIGeminiFlash1_5
+from langfun.core.llms.vertexai import VertexAIGeminiFlash1_5_002
+from langfun.core.llms.vertexai import VertexAIGeminiFlash1_5_001
+from langfun.core.llms.vertexai import VertexAIGeminiPro1
+
+# Base for OpenAI-compatible models.
+from langfun.core.llms.openai_compatible import OpenAICompatible
 
 # OpenAI models.
 from langfun.core.llms.openai import OpenAI
 
+from langfun.core.llms.openai import GptO1
+from langfun.core.llms.openai import GptO1Preview
+from langfun.core.llms.openai import GptO1Preview_20240912
+from langfun.core.llms.openai import GptO1Mini
+from langfun.core.llms.openai import GptO1Mini_20240912
+
+from langfun.core.llms.openai import Gpt4oMini
+from langfun.core.llms.openai import Gpt4oMini_20240718
+from langfun.core.llms.openai import Gpt4o
+from langfun.core.llms.openai import Gpt4o_20241120
+from langfun.core.llms.openai import Gpt4o_20240806
+from langfun.core.llms.openai import Gpt4o_20240513
+
 from langfun.core.llms.openai import Gpt4Turbo
 from langfun.core.llms.openai import Gpt4Turbo_20240409
 from langfun.core.llms.openai import Gpt4TurboPreview
-from langfun.core.llms.openai import Gpt4TurboPreview_0125
-from langfun.core.llms.openai import Gpt4TurboPreview_1106
+from langfun.core.llms.openai import Gpt4TurboPreview_20240125
+from langfun.core.llms.openai import Gpt4TurboPreview_20231106
 from langfun.core.llms.openai import Gpt4VisionPreview
-from langfun.core.llms.openai import Gpt4VisionPreview_1106
+from langfun.core.llms.openai import Gpt4VisionPreview_20231106
 from langfun.core.llms.openai import Gpt4
-from langfun.core.llms.openai import Gpt4_0613
+from langfun.core.llms.openai import Gpt4_20230613
+
 from langfun.core.llms.openai import Gpt4_32K
-from langfun.core.llms.openai import Gpt4_32K_0613
+from langfun.core.llms.openai import Gpt4_32K_20230613
 
 from langfun.core.llms.openai import Gpt35Turbo
-from langfun.core.llms.openai import Gpt35Turbo_0125
-from langfun.core.llms.openai import Gpt35Turbo_1106
-from langfun.core.llms.openai import Gpt35Turbo_0613
+from langfun.core.llms.openai import Gpt35Turbo_20240125
+from langfun.core.llms.openai import Gpt35Turbo_20231106
+from langfun.core.llms.openai import Gpt35Turbo_20230613
 from langfun.core.llms.openai import Gpt35Turbo16K
-from langfun.core.llms.openai import Gpt35Turbo16K_0613
-
+from langfun.core.llms.openai import Gpt35Turbo16K_20230613
+
+# For backward compatibility.
+Gpt4TurboPreview_0125 = Gpt4TurboPreview_20240125
+Gpt4TurboPreview_1106 = Gpt4TurboPreview_20231106
+Gpt4VisionPreview_1106 = Gpt4VisionPreview_20231106
+Gpt4_0613 = Gpt4_20230613
+Gpt4_32K_0613 = Gpt4_32K_20230613
+Gpt35Turbo_0125 = Gpt35Turbo_20240125
+Gpt35Turbo_1106 = Gpt35Turbo_20231106
+Gpt35Turbo_0613 = Gpt35Turbo_20230613
+Gpt35Turbo16K_0613 = Gpt35Turbo16K_20230613
 
 from langfun.core.llms.openai import Gpt35
 
@@ -62,21 +115,39 @@ from langfun.core.llms.openai import Gpt3Babbage
 from langfun.core.llms.openai import Gpt3Ada
 
 from langfun.core.llms.anthropic import Anthropic
+from langfun.core.llms.anthropic import Claude35Sonnet
+from langfun.core.llms.anthropic import Claude35Sonnet20241022
+from langfun.core.llms.anthropic import Claude35Sonnet20240620
 from langfun.core.llms.anthropic import Claude3Opus
 from langfun.core.llms.anthropic import Claude3Sonnet
 from langfun.core.llms.anthropic import Claude3Haiku
+from langfun.core.llms.anthropic import VertexAIAnthropic
+from langfun.core.llms.anthropic import VertexAIClaude3_5_Sonnet_20241022
+from langfun.core.llms.anthropic import VertexAIClaude3_5_Sonnet_20240620
+from langfun.core.llms.anthropic import VertexAIClaude3_5_Haiku_20241022
+from langfun.core.llms.anthropic import VertexAIClaude3_Opus_20240229
 
 from langfun.core.llms.groq import Groq
+from langfun.core.llms.groq import GroqLlama3_2_3B
+from langfun.core.llms.groq import GroqLlama3_2_1B
+from langfun.core.llms.groq import GroqLlama3_1_70B
+from langfun.core.llms.groq import GroqLlama3_1_8B
 from langfun.core.llms.groq import GroqLlama3_70B
 from langfun.core.llms.groq import GroqLlama3_8B
 from langfun.core.llms.groq import GroqLlama2_70B
 from langfun.core.llms.groq import GroqMistral_8x7B
-from langfun.core.llms.groq import GroqGemma7B_IT
-
+from langfun.core.llms.groq import GroqGemma2_9B_IT
+from langfun.core.llms.groq import GroqGemma_7B_IT
+from langfun.core.llms.groq import GroqWhisper_Large_v3
+from langfun.core.llms.groq import GroqWhisper_Large_v3Turbo
 
 # LLaMA C++ models.
 from langfun.core.llms.llama_cpp import LlamaCppRemote
 
+# DeepSeek models.
+from langfun.core.llms.deepseek import DeepSeek
+from langfun.core.llms.deepseek import DeepSeekChat
+
 # Placeholder for Google-internal imports.
 
 # Include cache as sub-module.

langfun/core/llms/anthropic.py

@@ -16,12 +16,26 @@
 import base64
 import functools
 import os
-from typing import Annotated, Any
+from typing import Annotated, Any, Literal
 
 import langfun.core as lf
 from langfun.core import modalities as lf_modalities
+from langfun.core.llms import rest
 import pyglove as pg
-import requests
+
+
+try:
+  # pylint: disable=g-import-not-at-top
+  from google import auth as google_auth
+  from google.auth import credentials as credentials_lib
+  from google.auth.transport import requests as auth_requests
+  Credentials = credentials_lib.Credentials
+  # pylint: enable=g-import-not-at-top
+except ImportError:
+  google_auth = None
+  auth_requests = None
+  credentials_lib = None
+  Credentials = Any  # pylint: disable=invalid-name
 
 
 SUPPORTED_MODELS_AND_SETTINGS = {
@@ -29,33 +43,106 @@ SUPPORTED_MODELS_AND_SETTINGS = {
     # 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),
+    # Price in US dollars at https://www.anthropic.com/pricing
+    # as of 2024-10-10.
+    # Anthropic models hosted on VertexAI.
+    'claude-3-5-sonnet-v2@20241022': pg.Dict(
+        max_tokens=8192,
+        rpm=1000,
+        tpm=100000,
+        cost_per_1k_input_tokens=0.003,
+        cost_per_1k_output_tokens=0.015,
+    ),
+    'claude-3-5-sonnet@20240620': pg.Dict(
+        max_tokens=8192,
+        rpm=1000,
+        tpm=100000,
+        cost_per_1k_input_tokens=0.003,
+        cost_per_1k_output_tokens=0.015,
+    ),
+    'claude-3-5-haiku@20241022': pg.Dict(
+        max_tokens=8192,
+        rpm=1000,
+        tpm=100000,
+        cost_per_1k_input_tokens=0.001,
+        cost_per_1k_output_tokens=0.005,
+    ),
+    'claude-3-opus@20240229': pg.Dict(
+        max_tokens=4096,
+        rpm=4000,
+        tpm=400000,
+        cost_per_1k_input_tokens=0.015,
+        cost_per_1k_output_tokens=0.075,
+    ),
+    # Anthropic hosted models.
+    'claude-3-5-sonnet-20241022': pg.Dict(
+        max_tokens=8192,
+        rpm=4000,
+        tpm=400000,
+        cost_per_1k_input_tokens=0.003,
+        cost_per_1k_output_tokens=0.015,
+    ),
+    'claude-3-5-sonnet-20240620': pg.Dict(
+        max_tokens=8192,
+        rpm=4000,
+        tpm=400000,
+        cost_per_1k_input_tokens=0.003,
+        cost_per_1k_output_tokens=0.015,
+    ),
+    'claude-3-5-haiku-20241022': pg.Dict(
+        max_tokens=8192,
+        rpm=4000,
+        tpm=400000,
+        cost_per_1k_input_tokens=0.001,
+        cost_per_1k_output_tokens=0.005,
+    ),
+    'claude-3-opus-20240229': pg.Dict(
+        max_tokens=4096,
+        rpm=4000,
+        tpm=400000,
+        cost_per_1k_input_tokens=0.015,
+        cost_per_1k_output_tokens=0.075,
+    ),
+    'claude-3-sonnet-20240229': pg.Dict(
+        max_tokens=4096,
+        rpm=4000,
+        tpm=400000,
+        cost_per_1k_input_tokens=0.003,
+        cost_per_1k_output_tokens=0.015,
+    ),
+    'claude-3-haiku-20240307': pg.Dict(
+        max_tokens=4096,
+        rpm=4000,
+        tpm=400000,
+        cost_per_1k_input_tokens=0.00025,
+        cost_per_1k_output_tokens=0.00125,
+    ),
+    'claude-2.1': pg.Dict(
+        max_tokens=4096,
+        rpm=4000,
+        tpm=400000,
+        cost_per_1k_input_tokens=0.008,
+        cost_per_1k_output_tokens=0.024,
+    ),
+    'claude-2.0': pg.Dict(
+        max_tokens=4096,
+        rpm=4000,
+        tpm=400000,
+        cost_per_1k_input_tokens=0.008,
+        cost_per_1k_output_tokens=0.024,
+    ),
+    'claude-instant-1.2': pg.Dict(
+        max_tokens=4096,
+        rpm=4000,
+        tpm=400000,
+        cost_per_1k_input_tokens=0.0008,
+        cost_per_1k_output_tokens=0.0024,
+    ),
 }
 
 
-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):
+class Anthropic(rest.REST):
   """Anthropic LLMs (Claude) through REST APIs.
 
   See https://docs.anthropic.com/claude/reference/messages_post
@@ -80,14 +167,18 @@ class Anthropic(lf.LanguageModel):
       ),
   ] = None
 
+  api_endpoint: str = 'https://api.anthropic.com/v1/messages'
+
+  api_version: Annotated[
+      str,
+      'Anthropic API version.'
+  ] = '2023-06-01'
+
   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):
+  def _initialize(self):
     api_key = self.api_key or os.environ.get('ANTHROPIC_API_KEY', None)
     if not api_key:
       raise ValueError(
@@ -95,18 +186,16 @@ class Anthropic(lf.LanguageModel):
           '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({
+  @property
+  def headers(self) -> dict[str, Any]:
+    return {
         'x-api-key': self._api_key,
-        'anthropic-version': _ANTHROPIC_API_VERSION,
+        'anthropic-version': self.api_version,
         'content-type': 'application/json',
-    })
-    return s
+        # TODO(yifenglu): Remove beta flag once the feature is fully supported.
+        'anthropic-beta': 'pdfs-2024-09-25',
+    }
 
   @property
   def model_id(self) -> str:
@@ -121,13 +210,43 @@ class Anthropic(lf.LanguageModel):
         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 estimate_cost(
+      self,
+      num_input_tokens: int,
+      num_output_tokens: int
+  ) -> float | None:
+    """Estimate the cost based on usage."""
+    cost_per_1k_input_tokens = SUPPORTED_MODELS_AND_SETTINGS[self.model].get(
+        'cost_per_1k_input_tokens', None
+    )
+    cost_per_1k_output_tokens = SUPPORTED_MODELS_AND_SETTINGS[self.model].get(
+        'cost_per_1k_output_tokens', None
     )
+    if cost_per_1k_output_tokens is None or cost_per_1k_input_tokens is None:
+      return None
+    return (
+        cost_per_1k_input_tokens * num_input_tokens
+        + cost_per_1k_output_tokens * num_output_tokens
+    ) / 1000
+
+  def request(
+      self,
+      prompt: lf.Message,
+      sampling_options: lf.LMSamplingOptions
+  ) -> dict[str, Any]:
+    """Returns the JSON input for a message."""
+    request = dict()
+    request.update(self._request_args(sampling_options))
+    request.update(
+        dict(
+            messages=[
+                dict(role='user', content=self._content_from_message(prompt))
+            ]
+        )
+    )
+    return request
 
-  def _get_request_args(self, options: lf.LMSamplingOptions) -> dict[str, Any]:
+  def _request_args(self, options: lf.LMSamplingOptions) -> dict[str, Any]:
     """Returns a dict as request arguments."""
     # Authropic requires `max_tokens` to be specified.
     max_tokens = (
@@ -158,7 +277,6 @@ class Anthropic(lf.LanguageModel):
         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(
@@ -167,6 +285,15 @@ class Anthropic(lf.LanguageModel):
                   data=base64.b64encode(chunk.to_bytes()).decode(),
               ),
           )
+        elif isinstance(chunk, lf_modalities.PDF):
+          item = dict(
+              type='document',
+              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)
@@ -174,6 +301,23 @@ class Anthropic(lf.LanguageModel):
     else:
       return [dict(type='text', text=prompt.text)]
 
+  def result(self, json: dict[str, Any]) -> lf.LMSamplingResult:
+    message = self._message_from_content(json['content'])
+    input_tokens = json['usage']['input_tokens']
+    output_tokens = json['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,
+            estimated_cost=self.estimate_cost(
+                num_input_tokens=input_tokens,
+                num_output_tokens=output_tokens,
+            ),
+        ),
+    )
+
   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
@@ -181,55 +325,29 @@ class Anthropic(lf.LanguageModel):
         [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 Claude35Sonnet(Claude3):
+  """A balance between between Opus and Haiku."""
+  model = 'claude-3-5-sonnet-20241022'
+
+
+class Claude35Sonnet20241022(Claude3):
+  """A balance between between Opus and Haiku."""
+
+  model = 'claude-3-5-sonnet-20241022'
+
+
+class Claude35Sonnet20240620(Claude3):
+  """A balance between between Opus and Haiku."""
+
+  model = 'claude-3-5-sonnet-20240620'
+
+
 class Claude3Opus(Claude3):
   """Anthropic's most powerful model."""
 
@@ -261,3 +379,110 @@ class Claude21(Anthropic):
 class ClaudeInstant(Anthropic):
   """Cheapest small and fast model, 100K context window."""
   model = 'claude-instant-1.2'
+
+
+#
+# Authropic models on VertexAI.
+#
+
+
+class VertexAIAnthropic(Anthropic):
+  """Anthropic models on VertexAI."""
+
+  project: Annotated[
+      str | None,
+      'Google Cloud project ID.',
+  ] = None
+
+  location: Annotated[
+      Literal['us-east5', 'europe-west1'],
+      'GCP location with Anthropic models hosted.'
+  ] = 'us-east5'
+
+  credentials: Annotated[
+      Credentials | None,    # pytype: disable=invalid-annotation
+      (
+          'Credentials to use. If None, the default credentials '
+          'to the environment will be used.'
+      ),
+  ] = None
+
+  api_version = 'vertex-2023-10-16'
+
+  def _on_bound(self):
+    super()._on_bound()
+    if google_auth is None:
+      raise ValueError(
+          'Please install "langfun[llm-google-vertex]" to use Vertex AI models.'
+      )
+    self._project = None
+    self._credentials = None
+
+  def _initialize(self):
+    project = self.project or os.environ.get('VERTEXAI_PROJECT', None)
+    if not project:
+      raise ValueError(
+          'Please specify `project` during `__init__` or set environment '
+          'variable `VERTEXAI_PROJECT` with your Vertex AI project ID.'
+      )
+    self._project = project
+    credentials = self.credentials
+    if credentials is None:
+      # Use default credentials.
+      credentials = google_auth.default(
+          scopes=['https://www.googleapis.com/auth/cloud-platform']
+      )
+    self._credentials = credentials
+
+  @functools.cached_property
+  def _session(self):
+    assert self._api_initialized
+    assert self._credentials is not None
+    assert auth_requests is not None
+    s = auth_requests.AuthorizedSession(self._credentials)
+    s.headers.update(self.headers or {})
+    return s
+
+  @property
+  def headers(self):
+    return {
+        'Content-Type': 'application/json; charset=utf-8',
+    }
+
+  @property
+  def api_endpoint(self) -> str:
+    return (
+        f'https://{self.location}-aiplatform.googleapis.com/v1/projects/'
+        f'{self._project}/locations/{self.location}/publishers/anthropic/'
+        f'models/{self.model}:streamRawPredict'
+    )
+
+  def request(
+      self,
+      prompt: lf.Message,
+      sampling_options: lf.LMSamplingOptions
+  ):
+    request = super().request(prompt, sampling_options)
+    request['anthropic_version'] = self.api_version
+    del request['model']
+    return request
+
+
+class VertexAIClaude3_Opus_20240229(VertexAIAnthropic):  # pylint: disable=invalid-name
+  """Anthropic's Claude 3 Opus model on VertexAI."""
+  model = 'claude-3-opus@20240229'
+
+
+class VertexAIClaude3_5_Sonnet_20241022(VertexAIAnthropic):  # pylint: disable=invalid-name
+  """Anthropic's Claude 3.5 Sonnet model on VertexAI."""
+  model = 'claude-3-5-sonnet-v2@20241022'
+
+
+class VertexAIClaude3_5_Sonnet_20240620(VertexAIAnthropic):  # pylint: disable=invalid-name
+  """Anthropic's Claude 3.5 Sonnet model on VertexAI."""
+  model = 'claude-3-5-sonnet@20240620'
+
+
+class VertexAIClaude3_5_Haiku_20241022(VertexAIAnthropic):  # pylint: disable=invalid-name
+  """Anthropic's Claude 3.5 Haiku model on VertexAI."""
+  model = 'claude-3-5-haiku@20241022'