langfun 0.1.2.dev202509120804__py3-none-any.whl → 0.1.2.dev202512040805__py3-none-any.whl

langfun/core/llms/gemini_test.py

@@ -177,6 +177,58 @@ class GeminiTest(unittest.TestCase):
         ),
     )
 
+    # Add test for thinkingConfig with thinking_level.
+    actual = model._generation_config(
+        lf.UserMessage('hi'),
+        lf.LMSamplingOptions(
+            thinking_level='high',
+        ),
+    )
+    self.assertEqual(
+        actual,
+        dict(
+            candidateCount=1,
+            temperature=None,
+            topP=None,
+            topK=40,
+            maxOutputTokens=None,
+            stopSequences=None,
+            responseLogprobs=False,
+            logprobs=None,
+            seed=None,
+            thinkingConfig={'thinkingLevel': 'high'},
+        ),
+    )
+
+    # Add test for thinkingConfig with both max_thinking_tokens and
+    # thinking_level.
+    actual = model._generation_config(
+        lf.UserMessage('hi'),
+        lf.LMSamplingOptions(
+            max_thinking_tokens=100,
+            thinking_level='low',
+        ),
+    )
+    self.assertEqual(
+        actual,
+        dict(
+            candidateCount=1,
+            temperature=None,
+            topP=None,
+            topK=40,
+            maxOutputTokens=None,
+            stopSequences=None,
+            responseLogprobs=False,
+            logprobs=None,
+            seed=None,
+            thinkingConfig={
+                'includeThoughts': True,
+                'thinkingBudget': 100,
+                'thinkingLevel': 'low',
+            },
+        ),
+    )
+
     with self.assertRaisesRegex(
         ValueError, '`json_schema` must be a dict, got'
     ):
@@ -185,6 +237,32 @@ class GeminiTest(unittest.TestCase):
           lf.LMSamplingOptions(),
       )
 
+  def test_media_resolution_for_gemini3(self):
+    model = gemini.Gemini('gemini-3-pro-preview', api_endpoint='')
+    config = model._generation_config(
+        lf.UserMessage('hi'),
+        lf.LMSamplingOptions(),
+    )
+    self.assertEqual(config.get('mediaResolution'), 'MEDIA_RESOLUTION_HIGH')
+
+    model = gemini.Gemini('gemini-1.5-pro', api_endpoint='')
+    config = model._generation_config(
+        lf.UserMessage('hi'),
+        lf.LMSamplingOptions(),
+    )
+    self.assertIsNone(config.get('mediaResolution'))
+
+  def test_request_tool_config(self):
+    model = gemini.Gemini('gemini-1.5-pro', api_endpoint='')
+    request = model.request(
+        lf.UserMessage('hi'),
+        lf.LMSamplingOptions(),
+    )
+    self.assertEqual(
+        request.get('toolConfig'),
+        {'functionCallingConfig': {'mode': 'NONE'}},
+    )
+
   def test_call_model(self):
     with mock.patch('requests.Session.post') as mock_generate:
       mock_generate.side_effect = mock_requests_post
@@ -225,6 +303,38 @@ class GeminiTest(unittest.TestCase):
       ):
         lm('hello')
 
+  def test_call_model_with_max_tokens_error(self):
+    def mock_requests_post_error(*args, **kwargs):
+      del args, kwargs
+      response = requests.Response()
+      response.status_code = 200
+      response._content = pg.to_json_str({
+          'candidates': [
+              {
+                  'finishReason': 'MAX_TOKENS',
+                  'content': {
+                      'parts': [
+                          {
+                              'text': 'This is'
+                          }
+                      ]
+                  }
+              },
+          ],
+          'usageMetadata': {
+              'promptTokenCount': 3,
+              'candidatesTokenCount': 4,
+          }
+      }).encode()
+      return response
+
+    with mock.patch('requests.Session.post') as mock_generate:
+      mock_generate.side_effect = mock_requests_post_error
+      lm = gemini.Gemini('gemini-1.5-pro', api_endpoint='')
+      m = lm('hello')
+      self.assertEqual(m.metadata.finish_reason, 'MAX_TOKENS')
+      self.assertEqual(m.text, 'This is')
+
   def test_call_model_with_system_message(self):
     with mock.patch('requests.Session.post') as mock_generate:
       mock_generate.side_effect = mock_requests_post

langfun/core/llms/google_genai.py

@@ -25,7 +25,35 @@ import pyglove as pg
 @lf.use_init_args(['model'])
 @pg.members([('api_endpoint', pg.typing.Str().freeze(''))])
 class GenAI(gemini.Gemini):
-  """Language models provided by Google GenAI."""
+  """Google GenAI models.
+
+  **Quick Start:**
+
+  ```python
+  import langfun as lf
+
+  # Call Gemini 1.5 Flash using API key from environment variable
+  # 'GOOGLE_API_KEY'.
+  lm = lf.llms.Gemini15Flash()
+  r = lm('Who are you?')
+  print(r)
+  ```
+
+  **Setting up API key:**
+
+  The Google API key can be specified in following ways:
+
+  1. At model instantiation:
+
+     ```python
+     lm = lf.llms.Gemini15Flash(api_key='MY_API_KEY')
+     ```
+  2. via environment variable `GOOGLE_API_KEY`.
+
+  **References:**
+
+  *   https://ai.google.dev/docs
+  """
 
   model: pg.typing.Annotated[
       pg.typing.Enum(
@@ -87,9 +115,14 @@ class GenAI(gemini.Gemini):
 
 # pylint: disable=invalid-name
 
+
 #
 # Experimental models.
 #
+class Gemini3ProPreview(GenAI):
+  """Gemini 3 Pro Preview model."""
+
+  model = 'gemini-3-pro-preview'
 
 
 class Gemini25FlashImagePreview(GenAI):

langfun/core/llms/groq.py

@@ -259,10 +259,35 @@ _SUPPORTED_MODELS_BY_ID = {m.model_id: m for m in SUPPORTED_MODELS}
 
 
 @lf.use_init_args(['model'])
-class Groq(openai_compatible.OpenAICompatible):
-  """Groq LLMs through REST APIs (OpenAI compatible).
+class Groq(openai_compatible.OpenAIChatCompletionAPI):
+  """Groq models.
 
-  See https://platform.openai.com/docs/api-reference/chat
+  **Quick Start:**
+
+  ```python
+  import langfun as lf
+
+  # Call Llama 3.3 70B on Groq using API key from environment variable
+  # 'GROQ_API_KEY'.
+  lm = lf.llms.GroqLlama33_70B_Versatile()
+  r = lm('Who are you?')
+  print(r)
+  ```
+
+  **Setting up API key:**
+
+  The Groq API key can be specified in following ways:
+
+  1. At model instantiation:
+
+     ```python
+     lm = lf.llms.GroqLlama33_70B_Versatile(api_key='MY_API_KEY')
+     ```
+  2. via environment variable `GROQ_API_KEY`.
+
+  **References:**
+
+  *   https://console.groq.com/docs
   """
 
   model: pg.typing.Annotated[

langfun/core/llms/llama_cpp.py

@@ -20,11 +20,30 @@ import pyglove as pg
 
 @pg.use_init_args(['url', 'model'])
 @pg.members([('api_endpoint', pg.typing.Str().freeze(''))])
-class LlamaCppRemote(openai_compatible.OpenAICompatible):
-  """The remote LLaMA C++ model.
+class LlamaCppRemote(openai_compatible.OpenAIChatCompletionAPI):
+  """LLaMA C++ models served via a remote server.
 
-  The Remote LLaMA C++ models can be launched via
-  https://github.com/ggerganov/llama.cpp/tree/master/examples/server
+  This class provides an interface to interact with language models
+  hosted on a LLaMA C++ server, which is compatible with the OpenAI
+  Chat Completions API format.
+
+  **Quick Start:**
+
+  Assuming a LLaMA C++ server is running at `http://localhost:8080`,
+  you can interact with it as follows:
+
+  ```python
+  import langfun as lf
+
+  # If model name is not specified, it will use server's default.
+  lm = lf.llms.LlamaCppRemote(url='http://localhost:8080')
+  r = lm('Who are you?')
+  print(r)
+  ```
+
+  **References:**
+
+  *   https://github.com/ggerganov/llama.cpp/tree/master/examples/server
   """
   url: Annotated[
       str,

langfun/core/llms/openai.py

@@ -49,6 +49,75 @@ class OpenAIModelInfo(lf.ModelInfo):
 #
 
 SUPPORTED_MODELS = [
+    # GPT-5 models
+    OpenAIModelInfo(
+        model_id='gpt-5.1',
+        in_service=True,
+        model_type='instruction-tuned',
+        description='GPT 5.1 model (latest stable).',
+        url='https://platform.openai.com/docs/models/gpt-5.1',
+        input_modalities=OpenAIModelInfo.INPUT_IMAGE_TYPES,
+        context_length=lf.ModelInfo.ContextLength(
+            max_input_tokens=400_000,
+            max_output_tokens=128_000,
+        ),
+        pricing=lf.ModelInfo.Pricing(
+            cost_per_1m_cached_input_tokens=0.13,
+            cost_per_1m_input_tokens=1.25,
+            cost_per_1m_output_tokens=10.0,
+        ),
+        # Tier 5 rate limits.
+        rate_limits=lf.ModelInfo.RateLimits(
+            max_requests_per_minute=15_000,
+            max_tokens_per_minute=40_000_000,
+        ),
+    ),
+    OpenAIModelInfo(
+        model_id='gpt-5',
+        alias_for='gpt-5-2025-08-07',
+        in_service=True,
+        model_type='instruction-tuned',
+        description='GPT 5 model (latest stable).',
+        url='https://platform.openai.com/docs/models/gpt-5',
+        input_modalities=OpenAIModelInfo.INPUT_IMAGE_TYPES,
+        context_length=lf.ModelInfo.ContextLength(
+            max_input_tokens=400_000,
+            max_output_tokens=128_000,
+        ),
+        pricing=lf.ModelInfo.Pricing(
+            cost_per_1m_cached_input_tokens=0.125,
+            cost_per_1m_input_tokens=1.25,
+            cost_per_1m_output_tokens=10.0,
+        ),
+        # Tier 5 rate limits.
+        rate_limits=lf.ModelInfo.RateLimits(
+            max_requests_per_minute=15_000,
+            max_tokens_per_minute=40_000_000,
+        ),
+    ),
+    OpenAIModelInfo(
+        model_id='gpt-5-mini',
+        alias_for='gpt-5-mini-2025-08-07',
+        in_service=True,
+        model_type='instruction-tuned',
+        description='GPT 5 mini model (latest stable).',
+        url='https://platform.openai.com/docs/models/gpt-5-mini',
+        input_modalities=OpenAIModelInfo.INPUT_IMAGE_TYPES,
+        context_length=lf.ModelInfo.ContextLength(
+            max_input_tokens=400_000,
+            max_output_tokens=128_000,
+        ),
+        pricing=lf.ModelInfo.Pricing(
+            cost_per_1m_cached_input_tokens=0.025,
+            cost_per_1m_input_tokens=0.25,
+            cost_per_1m_output_tokens=2.0,
+        ),
+        # Tier 5 rate limits.
+        rate_limits=lf.ModelInfo.RateLimits(
+            max_requests_per_minute=180_000_000,
+            max_tokens_per_minute=30_000_000,
+        ),
+    ),
     # GPT-4.1 models
     OpenAIModelInfo(
         model_id='gpt-4.1',
@@ -984,8 +1053,36 @@ _SUPPORTED_MODELS_BY_MODEL_ID = {m.model_id: m for m in SUPPORTED_MODELS}
 
 
 @lf.use_init_args(['model'])
-class OpenAI(openai_compatible.OpenAICompatible):
-  """OpenAI model."""
+class OpenAI(openai_compatible.OpenAIResponsesAPI):
+  """OpenAI models.
+
+  **Quick Start:**
+
+  ```python
+  import langfun as lf
+
+  # Call GPT-4o using API key from environment variable 'OPENAI_API_KEY'.
+  lm = lf.llms.Gpt4o()
+  r = lm('Who are you?')
+  print(r)
+  ```
+
+  **Setting up API key:**
+
+  The OpenAI API key can be specified in following ways:
+
+  1. At model instantiation:
+
+     ```python
+     lm = lf.llms.Gpt4o(api_key='MY_API_KEY')
+     ```
+  2. via environment variable `OPENAI_API_KEY`.
+
+  **References:**
+
+  *   https://platform.openai.com/docs/models
+  *   https://platform.openai.com/docs/api-reference
+  """
 
   model: pg.typing.Annotated[
       pg.typing.Enum(
@@ -994,7 +1091,12 @@ class OpenAI(openai_compatible.OpenAICompatible):
       'The name of the model to use.',
   ]
 
-  api_endpoint: str = 'https://api.openai.com/v1/chat/completions'
+  # Disable message storage by default.
+  sampling_options = lf.LMSamplingOptions(
+      extras={'store': False}
+  )
+
+  api_endpoint: str = 'https://api.openai.com/v1/responses'
 
   api_key: Annotated[
       str | None,
@@ -1069,6 +1171,21 @@ class OpenAI(openai_compatible.OpenAICompatible):
     return super()._request_args(options)
 
 
+class Gpt51(OpenAI):
+  """GPT-5.1."""
+  model = 'gpt-5.1'
+
+
+class Gpt5(OpenAI):
+  """GPT-5."""
+  model = 'gpt-5'
+
+
+class Gpt5Mini(OpenAI):
+  """GPT-5 mini."""
+  model = 'gpt-5-mini'
+
+
 class Gpt41(OpenAI):
   """GPT-4.1."""
   model = 'gpt-4.1'

langfun/core/llms/openai_compatible.py

@@ -23,8 +23,18 @@ import pyglove as pg
 
 
 @lf.use_init_args(['api_endpoint', 'model'])
-class OpenAICompatible(rest.REST):
-  """Base for OpenAI compatible models."""
+class OpenAIChatCompletionAPI(rest.REST):
+  """Base class for models compatible with OpenAI's Chat Completion API.
+
+  This class provides a common interface for language models that adhere to
+  the OpenAI Chat Completion API format, which is used by providers like
+  Groq, DeepSeek, and others. It standardizes request formatting and
+  response parsing for these models.
+
+  **References:**
+
+  *   https://platform.openai.com/docs/api-reference/chat
+  """
 
   model: Annotated[
       str, 'The name of the model to use.',
@@ -42,12 +52,14 @@ class OpenAICompatible(rest.REST):
     # Reference:
     # https://platform.openai.com/docs/api-reference/completions/create
     # NOTE(daiyip): options.top_k is not applicable.
-    args = dict(
-        n=options.n,
-        top_logprobs=options.top_logprobs,
-    )
+    args = {}
+
     if self.model:
       args['model'] = self.model
+    if options.n != 1:
+      args['n'] = options.n
+    if options.top_logprobs is not None:
+      args['top_logprobs'] = options.top_logprobs
     if options.logprobs:
       args['logprobs'] = options.logprobs
     if options.temperature is not None:
@@ -62,6 +74,8 @@ class OpenAICompatible(rest.REST):
       args['seed'] = options.random_seed
     if options.reasoning_effort is not None:
       args['reasoning_effort'] = options.reasoning_effort
+    if options.extras:
+      args.update(options.extras)
     return args
 
   def request(
@@ -72,27 +86,13 @@ class OpenAICompatible(rest.REST):
     """Returns the JSON input for a message."""
     request_args = self._request_args(sampling_options)
 
-    # Users could use `metadata_json_schema` to pass additional
-    # request arguments.
-    json_schema = prompt.metadata.get('json_schema')
-    if json_schema is not None:
-      if not isinstance(json_schema, dict):
-        raise ValueError(
-            f'`json_schema` must be a dict, got {json_schema!r}.'
-        )
-      if 'title' not in json_schema:
-        raise ValueError(
-            f'The root of `json_schema` must have a `title` field, '
-            f'got {json_schema!r}.'
-        )
+    # Handle structured output.
+    output_schema = self._structure_output_schema(prompt)
+    if output_schema is not None:
       request_args.update(
           response_format=dict(
               type='json_schema',
-              json_schema=dict(
-                  schema=json_schema,
-                  name=json_schema['title'],
-                  strict=True,
-              )
+              json_schema=output_schema,
           )
       )
       prompt.metadata.formatted_text = (
@@ -118,17 +118,43 @@ class OpenAICompatible(rest.REST):
       assert isinstance(system_message, lf.SystemMessage), type(system_message)
       messages.append(
           system_message.as_format(
-              'openai', chunk_preprocessor=modality_check
+              'openai_chat_completion_api', chunk_preprocessor=modality_check
           )
       )
     messages.append(
-        prompt.as_format('openai', chunk_preprocessor=modality_check)
+        prompt.as_format(
+            'openai_chat_completion_api',
+            chunk_preprocessor=modality_check
+        )
     )
     request = dict()
     request.update(request_args)
     request['messages'] = messages
     return request
 
+  def _structure_output_schema(
+      self, prompt: lf.Message
+  ) -> dict[str, Any] | None:
+    # Users could use `metadata_json_schema` to pass additional
+    # request arguments.
+    json_schema = prompt.metadata.get('json_schema')
+    if json_schema is not None:
+      if not isinstance(json_schema, dict):
+        raise ValueError(
+            f'`json_schema` must be a dict, got {json_schema!r}.'
+        )
+      if 'title' not in json_schema:
+        raise ValueError(
+            f'The root of `json_schema` must have a `title` field, '
+            f'got {json_schema!r}.'
+        )
+      return dict(
+          schema=json_schema,
+          name=json_schema['title'],
+          strict=True,
+      )
+    return None
+
   def _parse_choice(self, choice: dict[str, Any]) -> lf.LMSample:
     # Reference:
     # https://platform.openai.com/docs/api-reference/chat/object
@@ -144,7 +170,10 @@ class OpenAICompatible(rest.REST):
           for t in choice_logprobs['content']
       ]
     return lf.LMSample(
-        lf.Message.from_value(choice['message'], format='openai'),
+        lf.Message.from_value(
+            choice['message'],
+            format='openai_chat_completion_api'
+        ),
         score=0.0,
         logprobs=logprobs,
     )
@@ -169,3 +198,95 @@ class OpenAICompatible(rest.REST):
         or (status_code == 400 and b'string_above_max_length' in content)):
       return lf.ContextLimitError(f'{status_code}: {content}')
     return super()._error(status_code, content)
+
+
+class OpenAIResponsesAPI(OpenAIChatCompletionAPI):
+  """Base class for models compatible with OpenAI's Responses API.
+
+  This class provides a common interface for language models that adhere to
+  the new OpenAI Responses API format. It standardizes request formatting
+  and response parsing for these models, including handling instructions
+  (system messages) and structured outputs.
+
+  **References:**
+
+  *   https://platform.openai.com/docs/api-reference/responses
+  """
+
+  def _request_args(
+      self, options: lf.LMSamplingOptions) -> dict[str, Any]:
+    """Returns a dict as request arguments."""
+    if options.logprobs:
+      raise ValueError('logprobs is not supported on Responses API.')
+    if options.n != 1:
+      raise ValueError('n must be 1 for Responses API.')
+    return super()._request_args(options)
+
+  def request(
+      self,
+      prompt: lf.Message,
+      sampling_options: lf.LMSamplingOptions
+  ) -> dict[str, Any]:
+    """Returns the JSON input for a message."""
+    request_args = self._request_args(sampling_options)
+
+    # Handle structured output.
+    output_schema = self._structure_output_schema(prompt)
+    if output_schema is not None:
+      output_schema['type'] = 'json_schema'
+      request_args.update(text=dict(format=output_schema))
+      prompt.metadata.formatted_text = (
+          prompt.text
+          + '\n\n [RESPONSE FORMAT (not part of prompt)]\n'
+          + pg.to_json_str(request_args['text'], json_indent=2)
+      )
+
+    request = dict()
+    request.update(request_args)
+
+    # Users could use `metadata_system_message` to pass system message.
+    system_message = prompt.metadata.get('system_message')
+    if system_message:
+      assert isinstance(system_message, lf.SystemMessage), type(system_message)
+      request['instructions'] = system_message.text
+
+    # Prepare input.
+    def modality_check(chunk: str | lf.Modality) -> Any:
+      if (isinstance(chunk, lf_modalities.Mime)
+          and not self.supports_input(chunk.mime_type)):
+        raise ValueError(
+            f'Unsupported modality: {chunk!r}.'
+        )
+      return chunk
+
+    request['input'] = [
+        prompt.as_format(
+            'openai_responses_api',
+            chunk_preprocessor=modality_check
+        )
+    ]
+    return request
+
+  def _parse_output(self, output: dict[str, Any]) -> lf.LMSample:
+    for item in output:
+      if isinstance(item, dict) and item.get('type') == 'message':
+        return lf.LMSample(
+            lf.Message.from_value(item, format='openai_responses_api'),
+            score=0.0,
+        )
+    raise ValueError('No message found in output.')
+
+  def result(self, json: dict[str, Any]) -> lf.LMSamplingResult:
+    """Returns a LMSamplingResult from a JSON response."""
+    usage = json['usage']
+    return lf.LMSamplingResult(
+        samples=[self._parse_output(json['output'])],
+        usage=lf.LMSamplingUsage(
+            prompt_tokens=usage['input_tokens'],
+            completion_tokens=usage['output_tokens'],
+            total_tokens=usage['total_tokens'],
+            completion_tokens_details=usage.get(
+                'output_tokens_details', None
+            ),
+        ),
+    )