langchain-google-genai 3.0.0a1__tar.gz → 3.0.0rc1__tar.gz

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 3.0.0a1
+Version: 3.0.0rc1
 Summary: An integration package connecting Google's genai package and LangChain
 License: MIT
 Project-URL: Source Code, https://github.com/langchain-ai/langchain-google/tree/main/libs/genai
 Project-URL: Release Notes, https://github.com/langchain-ai/langchain-google/releases
 Project-URL: repository, https://github.com/langchain-ai/langchain-google
 Requires-Python: <4.0.0,>=3.10.0
-Requires-Dist: langchain-core<2.0.0,>=1.0.0a4
+Requires-Dist: langchain-core<2.0.0,>=1.0.0rc2
 Requires-Dist: google-ai-generativelanguage<1.0.0,>=0.7.0
 Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: filetype<2.0.0,>=1.2.0
@@ -76,7 +76,7 @@ Then use the `ChatGoogleGenerativeAI` interface:
 ```python
 from langchain_google_genai import ChatGoogleGenerativeAI
 
-llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash")
+llm = ChatGoogleGenerativeAI(model="gemini-flash-latest")
 response = llm.invoke("Sing a ballad of LangChain.")
 print(response.content)
 ```
@@ -97,7 +97,7 @@ Most Gemini models support image inputs.
 from langchain_core.messages import HumanMessage
 from langchain_google_genai import ChatGoogleGenerativeAI
 
-llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash")
+llm = ChatGoogleGenerativeAI(model="gemini-flash-latest")
 
 message = HumanMessage(
     content=[

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/README.md

@@ -61,7 +61,7 @@ Then use the `ChatGoogleGenerativeAI` interface:
 ```python
 from langchain_google_genai import ChatGoogleGenerativeAI
 
-llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash")
+llm = ChatGoogleGenerativeAI(model="gemini-flash-latest")
 response = llm.invoke("Sing a ballad of LangChain.")
 print(response.content)
 ```
@@ -82,7 +82,7 @@ Most Gemini models support image inputs.
 from langchain_core.messages import HumanMessage
 from langchain_google_genai import ChatGoogleGenerativeAI
 
-llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash")
+llm = ChatGoogleGenerativeAI(model="gemini-flash-latest")
 
 message = HumanMessage(
     content=[

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/langchain_google_genai/_compat.py

@@ -1,7 +1,7 @@
 """Go from v1 content blocks to generativelanguage_v1beta format."""
 
 import json
-from typing import Any, Optional
+from typing import Any, Optional, cast
 
 from langchain_core.messages import content as types
 
@@ -150,8 +150,6 @@ def _convert_from_v1_to_generativelanguage_v1beta(
         elif block_dict["type"] == "reasoning" and model_provider == "google_genai":
             # Google requires passing back the thought_signature when available.
             # Signatures are only provided when function calling is enabled.
-            # If no signature is available, we skip the reasoning block as it cannot
-            # be properly serialized back to the API.
             if "extras" in block_dict and isinstance(block_dict["extras"], dict):
                 extras = block_dict["extras"]
                 if "signature" in extras:
@@ -242,7 +240,47 @@ def _convert_from_v1_to_generativelanguage_v1beta(
             }
             new_content.append(function_call)
 
-        # NonStandardContentBlock
-        # TODO: Handle new server tools
+        elif block_dict["type"] == "server_tool_call":
+            if block_dict.get("name") == "code_interpreter":
+                # LangChain v0 format
+                args = cast(dict, block_dict.get("args", {}))
+                executable_code = {
+                    "type": "executable_code",
+                    "executable_code": args.get("code", ""),
+                    "language": args.get("language", ""),
+                    "id": block_dict.get("id", ""),
+                }
+                # Google generativelanguage format
+                new_content.append(
+                    {
+                        "executable_code": {
+                            "language": executable_code["language"],
+                            "code": executable_code["executable_code"],
+                        }
+                    }
+                )
+
+        elif block_dict["type"] == "server_tool_result":
+            extras = cast(dict, block_dict.get("extras", {}))
+            if extras.get("block_type") == "code_execution_result":
+                # LangChain v0 format
+                code_execution_result = {
+                    "type": "code_execution_result",
+                    "code_execution_result": block_dict.get("output", ""),
+                    "outcome": extras.get("outcome", ""),
+                    "tool_call_id": block_dict.get("tool_call_id", ""),
+                }
+                # Google generativelanguage format
+                new_content.append(
+                    {
+                        "code_execution_result": {
+                            "outcome": code_execution_result["outcome"],
+                            "output": code_execution_result["code_execution_result"],
+                        }
+                    }
+                )
+
+        elif block_dict["type"] == "non_standard":
+            new_content.append(block_dict["value"])
 
     return new_content

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/pyproject.toml

@@ -6,14 +6,14 @@ build-backend = "pdm.backend"
 
 [project]
 name = "langchain-google-genai"
-version = "3.0.0a1"
+version = "3.0.0rc1"
 description = "An integration package connecting Google's genai package and LangChain"
 authors = []
 requires-python = ">=3.10.0,<4.0.0"
 readme = "README.md"
 repository = "https://github.com/langchain-ai/langchain-google"
 dependencies = [
-    "langchain-core>=1.0.0a4,<2.0.0",
+    "langchain-core>=1.0.0rc2,<2.0.0",
     "google-ai-generativelanguage>=0.7.0,<1.0.0",
     "pydantic>=2.0.0,<3.0.0",
     "filetype>=1.2.0,<2.0.0",
@@ -49,23 +49,13 @@ test = [
     "pytest-socket>=0.7.0,<1.0.0",
     "numpy>=1.26.4; python_version<'3.13'",
     "numpy>=2.1.0; python_version>='3.13'",
-    "langchain-tests>=1.0.0a1,<2.0.0",
+    "langchain-tests>=1.0.0rc1,<2.0.0",
 ]
 test_integration = [
     "pytest>=8.4.0,<9.0.0",
 ]
 dev = []
 
-[tool.uv.sources.langchain-core]
-git = "https://github.com/langchain-ai/langchain.git"
-subdirectory = "libs/core"
-branch = "mdrxy/genai"
-
-[tool.uv.sources.langchain-tests]
-git = "https://github.com/langchain-ai/langchain.git"
-subdirectory = "libs/standard-tests"
-branch = "mdrxy/genai"
-
 [tool.ruff]
 fix = true
 

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/tests/integration_tests/test_callbacks.py

@@ -7,7 +7,7 @@ from langchain_core.prompts import PromptTemplate
 
 from langchain_google_genai import ChatGoogleGenerativeAI
 
-model_names = ["gemini-2.5-flash"]
+MODEL_NAMES = ["gemini-flash-lite-latest"]
 
 
 class StreamingLLMCallbackHandler(BaseCallbackHandler):
@@ -25,7 +25,7 @@ class StreamingLLMCallbackHandler(BaseCallbackHandler):
 
 @pytest.mark.parametrize(
     "model_name",
-    model_names,
+    MODEL_NAMES,
 )
 def test_streaming_callback(model_name: str) -> None:
     prompt_template = "Tell me details about the Company {name} with 2 bullet point?"

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/tests/integration_tests/test_chat_models.py

@@ -26,7 +26,7 @@ from langchain_google_genai import (
     Modality,
 )
 
-_MODEL = "models/gemini-2.5-flash"
+_MODEL = "gemini-flash-lite-latest"
 _VISION_MODEL = "models/gemini-2.0-flash-001"
 _IMAGE_OUTPUT_MODEL = "models/gemini-2.0-flash-exp-image-generation"
 _AUDIO_OUTPUT_MODEL = "models/gemini-2.5-flash-preview-tts"
@@ -263,6 +263,29 @@ def test_chat_google_genai_invoke_thinking() -> None:
         assert result.usage_metadata["output_token_details"]["reasoning"] > 0
 
 
+def _check_thinking_output(content: list, output_version: str) -> None:
+    if output_version == "v0":
+        thinking_key = "thinking"
+        assert isinstance(content[-1], str)
+
+    else:
+        # v1
+        thinking_key = "reasoning"
+        assert isinstance(content[-1], dict)
+        assert content[-1].get("type") == "text"
+        assert isinstance(content[-1].get("text"), str)
+
+    assert isinstance(content, list)
+    thinking_blocks = [
+        item
+        for item in content
+        if isinstance(item, dict) and item.get("type") == thinking_key
+    ]
+    assert thinking_blocks
+    for block in thinking_blocks:
+        assert isinstance(block[thinking_key], str)
+
+
 @pytest.mark.parametrize("output_version", ["v0", "v1"])
 def test_chat_google_genai_invoke_thinking_include_thoughts(
     output_version: str,
@@ -280,49 +303,31 @@ def test_chat_google_genai_invoke_thinking_include_thoughts(
         ),
     }
 
-    result = llm.invoke([input_message])
+    full: AIMessageChunk | None = None
+    for chunk in llm.stream([input_message]):
+        assert isinstance(chunk, AIMessageChunk)
+        full = chunk if full is None else full + chunk
 
-    assert isinstance(result, AIMessage)
-    content = result.content
+    assert isinstance(full, AIMessage)
 
-    response_metadata = result.response_metadata
+    response_metadata = full.response_metadata
     model_provider = response_metadata.get("model_provider", "google_genai")
     assert model_provider == "google_genai"
 
-    if output_version == "v0":
-        assert isinstance(content[0], dict)
-        assert content[0].get("type") == "thinking"
-        assert isinstance(content[0].get("thinking"), str)
-
-        assert isinstance(content[1], str)
-
-        _check_usage_metadata(result)
-
-        assert result.usage_metadata is not None
-        if (
-            "output_token_details" in result.usage_metadata
-            and "reasoning" in result.usage_metadata["output_token_details"]
-        ):
-            assert result.usage_metadata["output_token_details"]["reasoning"] > 0
-
-        # We don't test passing back in here as it's covered in the next test
-        # (Google requires function declaration)
-    else:
-        # v1
-        assert isinstance(content, list)
-        assert len(content) == 2
-        assert isinstance(content[0], dict)
-        assert content[0].get("type") == "reasoning"
-        assert isinstance(content[0].get("reasoning"), str)
-
-        assert isinstance(content[1], dict)
-        assert content[1].get("type") == "text"
-        assert isinstance(content[1].get("text"), str)
-
-        _check_usage_metadata(result)
+    _check_thinking_output(cast(list, full.content), output_version)
+    _check_usage_metadata(full)
+    assert full.usage_metadata is not None
+    if (
+        "output_token_details" in full.usage_metadata
+        and "reasoning" in full.usage_metadata["output_token_details"]
+    ):
+        assert full.usage_metadata["output_token_details"]["reasoning"] > 0
 
-        # We don't test passing back in here as it's covered in the next test
-        # (Google requires function declaration)
+    # Test we can pass back in
+    next_message = {"role": "user", "content": "Thanks!"}
+    result = llm.invoke([input_message, full, next_message])
+    assert isinstance(result, AIMessage)
+    _check_thinking_output(cast(list, result.content), output_version)
 
 
 @pytest.mark.flaky(retries=5, delay=1)
@@ -896,42 +901,47 @@ def test_model_methods_without_eventloop(is_async: bool, use_streaming: bool) ->
         assert isinstance(invoke_result, AIMessage)
 
 
-@pytest.mark.parametrize("use_streaming", [False, True])
-def test_search_builtin(use_streaming: bool) -> None:
-    llm = ChatGoogleGenerativeAI(model="models/gemini-2.0-flash-001").bind_tools(
-        [{"google_search": {}}]
-    )
+def _check_web_search_output(message: AIMessage, output_version: str) -> None:
+    assert "grounding_metadata" in message.response_metadata
+
+    # Lazy parsing
+    content_blocks = message.content_blocks
+    text_blocks = [block for block in content_blocks if block["type"] == "text"]
+    assert len(text_blocks) == 1
+    text_block = text_blocks[0]
+    assert text_block["annotations"]
+
+    if output_version == "v1":
+        text_blocks = [block for block in message.content if block["type"] == "text"]  # type: ignore[misc,index]
+        assert len(text_blocks) == 1
+        text_block = text_blocks[0]
+        assert text_block["annotations"]
+
+
+@pytest.mark.parametrize("output_version", ["v0", "v1"])
+def test_search_builtin(output_version: str) -> None:
+    llm = ChatGoogleGenerativeAI(
+        model="models/gemini-2.0-flash-001", output_version=output_version
+    ).bind_tools([{"google_search": {}}])
     input_message = {
         "role": "user",
         "content": "What is today's news?",
     }
 
-    if use_streaming:
-        # Test streaming
-        full: Optional[BaseMessageChunk] = None
-        for chunk in llm.stream([input_message]):
-            assert isinstance(chunk, AIMessageChunk)
-            full = chunk if full is None else full + chunk
-        assert isinstance(full, AIMessageChunk)
-        assert "grounding_metadata" in full.response_metadata
-
-        # Test we can process chat history without raising errors
-        next_message = {
-            "role": "user",
-            "content": "Tell me more about that last story.",
-        }
-        _ = llm.invoke([input_message, full, next_message])
-    else:
-        # Test invoke
-        response = llm.invoke([input_message])
-        assert "grounding_metadata" in response.response_metadata
+    full: Optional[BaseMessageChunk] = None
+    for chunk in llm.stream([input_message]):
+        assert isinstance(chunk, AIMessageChunk)
+        full = chunk if full is None else full + chunk
+    assert isinstance(full, AIMessageChunk)
+    _check_web_search_output(full, output_version)
 
-        # Test we can process chat history without raising errors
-        next_message = {
-            "role": "user",
-            "content": "Tell me more about that last story.",
-        }
-        _ = llm.invoke([input_message, response, next_message])
+    # Test we can process chat history without raising errors
+    next_message = {
+        "role": "user",
+        "content": "Tell me more about that last story.",
+    }
+    response = llm.invoke([input_message, full, next_message])
+    _check_web_search_output(response, output_version)
 
 
 @pytest.mark.parametrize("use_streaming", [False, True])
@@ -1055,70 +1065,45 @@ def test_search_builtin_with_citations(use_streaming: bool) -> None:
                         assert isinstance(google_metadata, dict)
 
 
+def _check_code_execution_output(message: AIMessage, output_version: str) -> None:
+    if output_version == "v0":
+        blocks = [block for block in message.content if isinstance(block, dict)]
+        expected_block_types = {"executable_code", "code_execution_result"}
+        assert {block.get("type") for block in blocks} == expected_block_types
+
+    else:
+        # v1
+        expected_block_types = {"server_tool_call", "server_tool_result", "text"}
+        assert {block["type"] for block in message.content} == expected_block_types  # type: ignore[index]
+
+    # Lazy parsing
+    expected_block_types = {"server_tool_call", "server_tool_result", "text"}
+    assert {block["type"] for block in message.content_blocks} == expected_block_types
+
+
 @pytest.mark.filterwarnings("ignore::UserWarning")
-@pytest.mark.parametrize("use_streaming", [False, True])
-def test_code_execution_builtin(use_streaming: bool) -> None:
-    llm = ChatGoogleGenerativeAI(model="models/gemini-2.0-flash-001").bind_tools(
-        [{"code_execution": {}}]
-    )
+@pytest.mark.parametrize("output_version", ["v0", "v1"])
+def test_code_execution_builtin(output_version: str) -> None:
+    llm = ChatGoogleGenerativeAI(
+        model="models/gemini-2.0-flash-001", output_version=output_version
+    ).bind_tools([{"code_execution": {}}])
     input_message = {
         "role": "user",
         "content": "What is 3^3?",
     }
 
-    if use_streaming:
-        # Test streaming mode
-        full: Optional[BaseMessageChunk] = None
-        for chunk in llm.stream([input_message]):
-            assert isinstance(chunk, AIMessageChunk)
-            full = chunk if full is None else full + chunk
-        assert isinstance(full, AIMessageChunk)
-
-        # Check raw content still has legacy format (backward compatibility)
-        blocks = [block for block in full.content if isinstance(block, dict)]
-        expected_block_types = {"executable_code", "code_execution_result"}
-        assert {block.get("type") for block in blocks} == expected_block_types
+    full: Optional[BaseMessageChunk] = None
+    for chunk in llm.stream([input_message]):
+        assert isinstance(chunk, AIMessageChunk)
+        full = chunk if full is None else full + chunk
+    assert isinstance(full, AIMessageChunk)
 
-        content_blocks = full.content_blocks
-        standard_blocks = [block for block in content_blocks if isinstance(block, dict)]
-        standard_types = {block.get("type") for block in standard_blocks}
-        assert (
-            "server_tool_call" in standard_types or "executable_code" in standard_types
-        )
-        assert (
-            "server_tool_result" in standard_types
-            or "code_execution_result" in standard_types
-        )
+    _check_code_execution_output(full, output_version)
 
-        # Test passing back in chat history without raising errors
-        next_message = {
-            "role": "user",
-            "content": "Can you show me the calculation again with comments?",
-        }
-        _ = llm.invoke([input_message, full, next_message])
-    else:
-        # Invoke
-        response = llm.invoke([input_message])
-        blocks = [block for block in response.content if isinstance(block, dict)]
-
-        # Check raw content still has legacy format (backward compatibility)
-        expected_block_types = {"executable_code", "code_execution_result"}
-        assert {block.get("type") for block in blocks} == expected_block_types
-
-        content_blocks = response.content_blocks
-        standard_blocks = [block for block in content_blocks if isinstance(block, dict)]
-        standard_types = {block.get("type") for block in standard_blocks}
-        assert (
-            "server_tool_call" in standard_types or "executable_code" in standard_types
-        )
-        assert (
-            "server_tool_result" in standard_types
-            or "code_execution_result" in standard_types
-        )
-
-        # Test passing back in chat history without raising errors
-        next_message = {
-            "role": "user",
-            "content": "Can you show me the calculation again with comments?",
-        }
-        _ = llm.invoke([input_message, response, next_message])
+    # Test passing back in chat history without raising errors
+    next_message = {
+        "role": "user",
+        "content": "Can you show me the calculation again with comments?",
+    }
+    response = llm.invoke([input_message, full, next_message])
+    _check_code_execution_output(response, output_version)

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/tests/integration_tests/test_function_call.py

@@ -11,12 +11,12 @@ from langchain_google_genai.chat_models import (
     ChatGoogleGenerativeAI,
 )
 
-model_names = ["gemini-2.5-flash"]
+MODEL_NAMES = ["gemini-flash-lite-latest"]
 
 
 @pytest.mark.parametrize(
     "model_name",
-    model_names,
+    MODEL_NAMES,
 )
 def test_function_call(model_name: str) -> None:
     functions = [
@@ -50,7 +50,7 @@ def test_function_call(model_name: str) -> None:
 
 @pytest.mark.parametrize(
     "model_name",
-    model_names,
+    MODEL_NAMES,
 )
 def test_tool_call(model_name: str) -> None:
     @tool
@@ -79,7 +79,7 @@ class MyModel(BaseModel):
 
 @pytest.mark.parametrize(
     "model_name",
-    model_names,
+    MODEL_NAMES,
 )
 def test_pydantic_call(model_name: str) -> None:
     llm = ChatGoogleGenerativeAI(model=model_name).bind(functions=[MyModel])

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/tests/integration_tests/test_llms.py

@@ -10,12 +10,12 @@ from langchain_core.outputs import LLMResult
 
 from langchain_google_genai import GoogleGenerativeAI, HarmBlockThreshold, HarmCategory
 
-model_names = ["gemini-2.5-flash"]
+MODEL_NAMES = ["gemini-flash-lite-latest"]
 
 
 @pytest.mark.parametrize(
     "model_name",
-    model_names,
+    MODEL_NAMES,
 )
 def test_google_generativeai_call(model_name: str) -> None:
     """Test valid call to Google GenerativeAI text API."""
@@ -31,7 +31,7 @@ def test_google_generativeai_call(model_name: str) -> None:
 
 @pytest.mark.parametrize(
     "model_name",
-    model_names,
+    MODEL_NAMES,
 )
 def test_google_generativeai_generate(model_name: str) -> None:
     llm = GoogleGenerativeAI(temperature=0.3, model=model_name)
@@ -47,7 +47,7 @@ def test_google_generativeai_generate(model_name: str) -> None:
 
 @pytest.mark.parametrize(
     "model_name",
-    model_names,
+    MODEL_NAMES,
 )
 async def test_google_generativeai_agenerate(model_name: str) -> None:
     llm = GoogleGenerativeAI(temperature=0, model=model_name)
@@ -57,7 +57,7 @@ async def test_google_generativeai_agenerate(model_name: str) -> None:
 
 @pytest.mark.parametrize(
     "model_name",
-    model_names,
+    MODEL_NAMES,
 )
 def test_generativeai_stream(model_name: str) -> None:
     llm = GoogleGenerativeAI(temperature=0, model=model_name)
@@ -67,7 +67,7 @@ def test_generativeai_stream(model_name: str) -> None:
 
 @pytest.mark.parametrize(
     "model_name",
-    model_names,
+    MODEL_NAMES,
 )
 def test_generativeai_get_num_tokens_gemini(model_name: str) -> None:
     llm = GoogleGenerativeAI(temperature=0, model=model_name)
@@ -77,7 +77,7 @@ def test_generativeai_get_num_tokens_gemini(model_name: str) -> None:
 
 @pytest.mark.parametrize(
     "model_name",
-    model_names,
+    MODEL_NAMES,
 )
 def test_safety_settings_gemini(model_name: str) -> None:
     # test with blocked prompt

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/tests/integration_tests/test_tools.py

@@ -2,6 +2,8 @@ from langchain_core.tools import tool
 
 from langchain_google_genai import ChatGoogleGenerativeAI
 
+MODEL = "gemini-flash-lite-latest"
+
 
 @tool
 def check_weather(location: str) -> str:
@@ -25,7 +27,7 @@ def test_multiple_tools() -> None:
     tools = [check_weather, check_live_traffic, check_tennis_score]
 
     model = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL,
     )
 
     model_with_tools = model.bind_tools(tools)

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/tests/unit_tests/test_chat_models.py

@@ -45,11 +45,13 @@ from langchain_google_genai.chat_models import (
     _response_to_result,
 )
 
+MODEL_NAME = "gemini-flash-lite-latest"
+
 
 def test_integration_initialization() -> None:
     """Test chat model initialization."""
     llm = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         google_api_key=SecretStr("..."),
         top_k=2,
         top_p=1,
@@ -59,27 +61,27 @@ def test_integration_initialization() -> None:
     ls_params = llm._get_ls_params()
     assert ls_params == {
         "ls_provider": "google_genai",
-        "ls_model_name": "gemini-2.5-flash",
+        "ls_model_name": MODEL_NAME,
         "ls_model_type": "chat",
         "ls_temperature": 0.7,
     }
 
     llm = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         google_api_key=SecretStr("..."),
         max_output_tokens=10,
     )
     ls_params = llm._get_ls_params()
     assert ls_params == {
         "ls_provider": "google_genai",
-        "ls_model_name": "gemini-2.5-flash",
+        "ls_model_name": MODEL_NAME,
         "ls_model_type": "chat",
         "ls_temperature": 0.7,
         "ls_max_tokens": 10,
     }
 
     ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         api_key=SecretStr("..."),
         top_k=2,
         top_p=1,
@@ -91,13 +93,13 @@ def test_integration_initialization() -> None:
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", UserWarning)
             llm = ChatGoogleGenerativeAI(
-                model="gemini-2.5-flash",
+                model=MODEL_NAME,
                 google_api_key=SecretStr("..."),
                 safety_setting={
                     "HARM_CATEGORY_DANGEROUS_CONTENT": "BLOCK_LOW_AND_ABOVE"
                 },  # Invalid arg
             )
-        assert llm.model == "models/gemini-2.5-flash"
+        assert llm.model == f"models/{MODEL_NAME}"
         mock_warning.assert_called_once()
         call_args = mock_warning.call_args[0][0]
         assert "Unexpected argument 'safety_setting'" in call_args
@@ -112,7 +114,7 @@ def test_safety_settings_initialization() -> None:
 
     # Test initialization with safety_settings
     llm = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         google_api_key=SecretStr("test-key"),
         temperature=0.7,
         safety_settings=safety_settings,
@@ -121,7 +123,7 @@ def test_safety_settings_initialization() -> None:
     # Verify the safety_settings are stored correctly
     assert llm.safety_settings == safety_settings
     assert llm.temperature == 0.7
-    assert llm.model == "models/gemini-2.5-flash"
+    assert llm.model == f"models/{MODEL_NAME}"
 
 
 def test_initialization_inside_threadpool() -> None:
@@ -130,30 +132,28 @@ def test_initialization_inside_threadpool() -> None:
     with ThreadPoolExecutor() as executor:
         executor.submit(
             ChatGoogleGenerativeAI,
-            model="gemini-2.5-flash",
+            model=MODEL_NAME,
             google_api_key=SecretStr("secret-api-key"),
         ).result()
 
 
 def test_client_transport() -> None:
     """Test client transport configuration."""
-    model = ChatGoogleGenerativeAI(model="gemini-2.5-flash", google_api_key="fake-key")
+    model = ChatGoogleGenerativeAI(model=MODEL_NAME, google_api_key="fake-key")
     assert model.client.transport.kind == "grpc"
 
     model = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash", google_api_key="fake-key", transport="rest"
+        model=MODEL_NAME, google_api_key="fake-key", transport="rest"
     )
     assert model.client.transport.kind == "rest"
 
     async def check_async_client() -> None:
-        model = ChatGoogleGenerativeAI(
-            model="gemini-2.5-flash", google_api_key="fake-key"
-        )
+        model = ChatGoogleGenerativeAI(model=MODEL_NAME, google_api_key="fake-key")
         assert model.async_client.transport.kind == "grpc_asyncio"
 
         # Test auto conversion of transport to "grpc_asyncio" from "rest"
         model = ChatGoogleGenerativeAI(
-            model="gemini-2.5-flash", google_api_key="fake-key", transport="rest"
+            model=MODEL_NAME, google_api_key="fake-key", transport="rest"
         )
         assert model.async_client.transport.kind == "grpc_asyncio"
 
@@ -162,7 +162,7 @@ def test_client_transport() -> None:
 
 def test_initalization_without_async() -> None:
     chat = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         google_api_key=SecretStr("secret-api-key"),
     )
     assert chat.async_client is None
@@ -171,7 +171,7 @@ def test_initalization_without_async() -> None:
 def test_initialization_with_async() -> None:
     async def initialize_chat_with_async_client() -> ChatGoogleGenerativeAI:
         model = ChatGoogleGenerativeAI(
-            model="gemini-2.5-flash",
+            model=MODEL_NAME,
             google_api_key=SecretStr("secret-api-key"),
         )
         _ = model.async_client
@@ -183,7 +183,7 @@ def test_initialization_with_async() -> None:
 
 def test_api_key_is_string() -> None:
     chat = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         google_api_key=SecretStr("secret-api-key"),
     )
     assert isinstance(chat.google_api_key, SecretStr)
@@ -193,7 +193,7 @@ def test_api_key_masked_when_passed_via_constructor(
     capsys: pytest.CaptureFixture,
 ) -> None:
     chat = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         google_api_key=SecretStr("secret-api-key"),
     )
     print(chat.google_api_key, end="")  # noqa: T201
@@ -399,7 +399,7 @@ def test_additional_headers_support(headers: Optional[dict[str, str]]) -> None:
         mock_client,
     ):
         chat = ChatGoogleGenerativeAI(
-            model="gemini-2.5-flash",
+            model=MODEL_NAME,
             google_api_key=param_secret_api_key,
             client_options=param_client_options,
             transport=param_transport,
@@ -437,7 +437,7 @@ def test_default_metadata_field_alias() -> None:
     # error
     # This is the main issue: LangSmith Playground passes None to default_metadata_input
     chat1 = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         google_api_key=SecretStr("test-key"),
         default_metadata_input=None,
     )
@@ -448,7 +448,7 @@ def test_default_metadata_field_alias() -> None:
     # Test with empty list for default_metadata_input (should not cause validation
     # error)
     chat2 = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         google_api_key=SecretStr("test-key"),
         default_metadata_input=[],
     )
@@ -457,7 +457,7 @@ def test_default_metadata_field_alias() -> None:
 
     # Test with tuple for default_metadata_input (should not cause validation error)
     chat3 = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         google_api_key=SecretStr("test-key"),
         default_metadata_input=[("X-Test", "test")],
     )
@@ -813,7 +813,7 @@ def test_parse_response_candidate_includes_model_name() -> None:
 
 
 def test_serialize() -> None:
-    llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash", google_api_key="test-key")
+    llm = ChatGoogleGenerativeAI(model=MODEL_NAME, google_api_key="test-key")
     serialized = dumps(llm)
     llm_loaded = loads(
         serialized,
@@ -852,20 +852,20 @@ def test__convert_tool_message_to_parts__sets_tool_name(
 def test_temperature_range_pydantic_validation() -> None:
     """Test that temperature is in the range [0.0, 2.0]."""
     with pytest.raises(ValidationError):
-        ChatGoogleGenerativeAI(model="gemini-2.5-flash", temperature=2.1)
+        ChatGoogleGenerativeAI(model=MODEL_NAME, temperature=2.1)
 
     with pytest.raises(ValidationError):
-        ChatGoogleGenerativeAI(model="gemini-2.5-flash", temperature=-0.1)
+        ChatGoogleGenerativeAI(model=MODEL_NAME, temperature=-0.1)
 
     llm = ChatGoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         google_api_key=SecretStr("..."),
         temperature=1.5,
     )
     ls_params = llm._get_ls_params()
     assert ls_params == {
         "ls_provider": "google_genai",
-        "ls_model_name": "gemini-2.5-flash",
+        "ls_model_name": MODEL_NAME,
         "ls_model_type": "chat",
         "ls_temperature": 1.5,
     }
@@ -874,30 +874,30 @@ def test_temperature_range_pydantic_validation() -> None:
 def test_temperature_range_model_validation() -> None:
     """Test that temperature is in the range [0.0, 2.0]."""
     with pytest.raises(ValueError):
-        ChatGoogleGenerativeAI(model="gemini-2.5-flash", temperature=2.5)
+        ChatGoogleGenerativeAI(model=MODEL_NAME, temperature=2.5)
 
     with pytest.raises(ValueError):
-        ChatGoogleGenerativeAI(model="gemini-2.5-flash", temperature=-0.5)
+        ChatGoogleGenerativeAI(model=MODEL_NAME, temperature=-0.5)
 
 
 def test_model_kwargs() -> None:
     """Test we can transfer unknown params to model_kwargs."""
     llm = ChatGoogleGenerativeAI(
-        model="my-model",
+        model=MODEL_NAME,
         convert_system_message_to_human=True,
         model_kwargs={"foo": "bar"},
     )
-    assert llm.model == "models/my-model"
+    assert llm.model == f"models/{MODEL_NAME}"
     assert llm.convert_system_message_to_human is True
     assert llm.model_kwargs == {"foo": "bar"}
 
     with pytest.warns(match="transferred to model_kwargs"):
         llm = ChatGoogleGenerativeAI(
-            model="my-model",
+            model=MODEL_NAME,
             convert_system_message_to_human=True,
             foo="bar",
         )
-    assert llm.model == "models/my-model"
+    assert llm.model == f"models/{MODEL_NAME}"
     assert llm.convert_system_message_to_human is True
     assert llm.model_kwargs == {"foo": "bar"}
 
@@ -1507,7 +1507,7 @@ def test_thinking_config_merging_with_generation_config() -> None:
         mock_retry.return_value = mock_response
 
         llm = ChatGoogleGenerativeAI(
-            model="gemini-2.5-flash",
+            model=MODEL_NAME,
             google_api_key=SecretStr("test-key"),
         )
 

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/tests/unit_tests/test_embeddings.py

@@ -14,6 +14,8 @@ from pydantic import SecretStr
 
 from langchain_google_genai.embeddings import GoogleGenerativeAIEmbeddings
 
+MODEL_NAME = "gemini-embedding-001"
+
 
 def test_integration_initialization() -> None:
     """Test chat model initialization."""
@@ -21,7 +23,7 @@ def test_integration_initialization() -> None:
         "langchain_google_genai._genai_extension.v1betaGenerativeServiceClient"
     ) as mock_prediction_service:
         _ = GoogleGenerativeAIEmbeddings(
-            model="models/gemini-embedding-001",
+            model=f"models/{MODEL_NAME}",
             google_api_key=SecretStr("..."),
         )
         mock_prediction_service.assert_called_once()
@@ -34,7 +36,7 @@ def test_integration_initialization() -> None:
         "langchain_google_genai._genai_extension.v1betaGenerativeServiceClient"
     ) as mock_prediction_service:
         _ = GoogleGenerativeAIEmbeddings(
-            model="models/gemini-embedding-001",
+            model=f"models/{MODEL_NAME}",
             google_api_key=SecretStr("..."),
             task_type="retrieval_document",
         )
@@ -43,7 +45,7 @@ def test_integration_initialization() -> None:
 
 def test_api_key_is_string() -> None:
     embeddings = GoogleGenerativeAIEmbeddings(
-        model="models/gemini-embedding-001",
+        model=f"models/{MODEL_NAME}",
         google_api_key=SecretStr("secret-api-key"),
     )
     assert isinstance(embeddings.google_api_key, SecretStr)
@@ -53,7 +55,7 @@ def test_api_key_masked_when_passed_via_constructor(
     capsys: pytest.CaptureFixture,
 ) -> None:
     embeddings = GoogleGenerativeAIEmbeddings(
-        model="models/gemini-embedding-001",
+        model=f"models/{MODEL_NAME}",
         google_api_key=SecretStr("secret-api-key"),
     )
     print(embeddings.google_api_key, end="")  # noqa: T201
@@ -72,13 +74,13 @@ def test_embed_query() -> None:
         )
         mock_prediction_service.return_value.embed_content = mock_embed
         llm = GoogleGenerativeAIEmbeddings(
-            model="models/embedding-test",
+            model=f"models/{MODEL_NAME}",
             google_api_key=SecretStr("test-key"),
             task_type="classification",
         )
         llm.embed_query("test text", output_dimensionality=524)
         request = EmbedContentRequest(
-            model="models/embedding-test",
+            model=f"models/{MODEL_NAME}",
             content={"parts": [{"text": "test text"}]},
             task_type="CLASSIFICATION",
             output_dimensionality=524,
@@ -97,22 +99,22 @@ def test_embed_documents() -> None:
         mock_prediction_service.return_value.batch_embed_contents = mock_embed
 
         llm = GoogleGenerativeAIEmbeddings(
-            model="models/embedding-test",
+            model=f"models/{MODEL_NAME}",
             google_api_key=SecretStr("test-key"),
         )
 
         llm.embed_documents(["test text", "test text2"], titles=["title1", "title2"])
         request = BatchEmbedContentsRequest(
-            model="models/embedding-test",
+            model=f"models/{MODEL_NAME}",
             requests=[
                 EmbedContentRequest(
-                    model="models/embedding-test",
+                    model=f"models/{MODEL_NAME}",
                     content={"parts": [{"text": "test text"}]},
                     task_type="RETRIEVAL_DOCUMENT",
                     title="title1",
                 ),
                 EmbedContentRequest(
-                    model="models/embedding-test",
+                    model=f"models/{MODEL_NAME}",
                     content={"parts": [{"text": "test text2"}]},
                     task_type="RETRIEVAL_DOCUMENT",
                     title="title2",
@@ -135,7 +137,7 @@ def test_embed_documents_with_numerous_texts() -> None:
         mock_prediction_service.return_value.batch_embed_contents = mock_embed
 
         llm = GoogleGenerativeAIEmbeddings(
-            model="models/embedding-test",
+            model=f"models/{MODEL_NAME}",
             google_api_key=SecretStr("test-key"),
         )
 
@@ -145,10 +147,10 @@ def test_embed_documents_with_numerous_texts() -> None:
             titles=["title1" for _ in range(test_corpus_size)],
         )
         request = BatchEmbedContentsRequest(
-            model="models/embedding-test",
+            model=f"models/{MODEL_NAME}",
             requests=[
                 EmbedContentRequest(
-                    model="models/embedding-test",
+                    model=f"models/{MODEL_NAME}",
                     content={"parts": [{"text": "test text"}]},
                     task_type="RETRIEVAL_DOCUMENT",
                     title="title1",

{langchain_google_genai-3.0.0a1 → langchain_google_genai-3.0.0rc1}/tests/unit_tests/test_llms.py

@@ -2,20 +2,22 @@ from unittest.mock import patch
 
 from langchain_google_genai.llms import GoogleGenerativeAI
 
+MODEL_NAME = "gemini-flash-lite-latest"
+
 
 def test_tracing_params() -> None:
     # Test standard tracing params
-    llm = GoogleGenerativeAI(model="gemini-2.5-flash", google_api_key="foo")
+    llm = GoogleGenerativeAI(model=MODEL_NAME, google_api_key="foo")
     ls_params = llm._get_ls_params()
     assert ls_params == {
         "ls_provider": "google_genai",
         "ls_model_type": "llm",
-        "ls_model_name": "gemini-2.5-flash",
+        "ls_model_name": MODEL_NAME,
         "ls_temperature": 0.7,
     }
 
     llm = GoogleGenerativeAI(
-        model="gemini-2.5-flash",
+        model=MODEL_NAME,
         temperature=0.1,
         max_output_tokens=10,
         google_api_key="foo",
@@ -24,7 +26,7 @@ def test_tracing_params() -> None:
     assert ls_params == {
         "ls_provider": "google_genai",
         "ls_model_type": "llm",
-        "ls_model_name": "gemini-2.5-flash",
+        "ls_model_name": MODEL_NAME,
         "ls_temperature": 0.1,
         "ls_max_tokens": 10,
     }
@@ -32,15 +34,15 @@ def test_tracing_params() -> None:
     # Test initialization with an invalid argument to check warning
     with patch("langchain_google_genai.llms.logger.warning") as mock_warning:
         llm = GoogleGenerativeAI(
-            model="gemini-2.5-flash",
+            model=MODEL_NAME,
             google_api_key="foo",
             safety_setting={
                 "HARM_CATEGORY_DANGEROUS_CONTENT": "BLOCK_LOW_AND_ABOVE"
             },  # Invalid arg
         )
-        assert llm.model == "models/gemini-2.5-flash"
+        assert llm.model == f"models/{MODEL_NAME}"
         ls_params = llm._get_ls_params()
-        assert ls_params.get("ls_model_name") == "gemini-2.5-flash"
+        assert ls_params.get("ls_model_name") == MODEL_NAME
         mock_warning.assert_called_once()
         call_args = mock_warning.call_args[0][0]
         assert "Unexpected argument 'safety_setting'" in call_args