langchain-google-genai 2.1.12__tar.gz → 3.0.0rc1__tar.gz

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

@@ -1,16 +1,16 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 2.1.12
+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: >=3.9
-Requires-Dist: langchain-core>=0.3.75
-Requires-Dist: google-ai-generativelanguage<1,>=0.7
-Requires-Dist: pydantic<3,>=2
-Requires-Dist: filetype<2,>=1.2
+Requires-Python: <4.0.0,>=3.10.0
+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
 Description-Content-Type: text/markdown
 
 # langchain-google-genai
@@ -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-2.1.12 → 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-2.1.12 → langchain_google_genai-3.0.0rc1}/langchain_google_genai/_common.py

@@ -52,7 +52,8 @@ Examples:
 
     max_output_tokens: Optional[int] = Field(default=None, alias="max_tokens")
     """Maximum number of tokens to include in a candidate. Must be greater than zero.
-    If unset, will default to ``64``."""
+    If unset, will use the model's default value, which varies by model.
+    See https://ai.google.dev/gemini-api/docs/models for model-specific limits."""
 
     n: int = 1
     """Number of chat completions to generate for each prompt. Note that the API may

langchain_google_genai-3.0.0rc1/langchain_google_genai/_compat.py

@@ -0,0 +1,286 @@
+"""Go from v1 content blocks to generativelanguage_v1beta format."""
+
+import json
+from typing import Any, Optional, cast
+
+from langchain_core.messages import content as types
+
+
+def translate_citations_to_grounding_metadata(
+    citations: list[types.Citation], web_search_queries: Optional[list[str]] = None
+) -> dict[str, Any]:
+    """Translate LangChain Citations to Google AI grounding metadata format.
+
+    Args:
+        citations: List of Citation content blocks.
+        web_search_queries: Optional list of search queries that generated
+            the grounding data.
+
+    Returns:
+        Google AI grounding metadata dictionary.
+
+    Example:
+        >>> citations = [
+        ...     create_citation(
+        ...         url="https://uefa.com/euro2024",
+        ...         title="UEFA Euro 2024 Results",
+        ...         start_index=0,
+        ...         end_index=47,
+        ...         cited_text="Spain won the UEFA Euro 2024 championship",
+        ...     )
+        ... ]
+        >>> metadata = translate_citations_to_grounding_metadata(citations)
+        >>> len(metadata["groundingChunks"])
+        1
+        >>> metadata["groundingChunks"][0]["web"]["uri"]
+        'https://uefa.com/euro2024'
+    """
+    if not citations:
+        return {}
+
+    # Group citations by text segment (start_index, end_index, cited_text)
+    segment_to_citations: dict[
+        tuple[Optional[int], Optional[int], Optional[str]], list[types.Citation]
+    ] = {}
+
+    for citation in citations:
+        key = (
+            citation.get("start_index"),
+            citation.get("end_index"),
+            citation.get("cited_text"),
+        )
+        if key not in segment_to_citations:
+            segment_to_citations[key] = []
+        segment_to_citations[key].append(citation)
+
+    # Build grounding chunks from unique URLs
+    url_to_chunk_index: dict[str, int] = {}
+    grounding_chunks: list[dict[str, Any]] = []
+
+    for citation in citations:
+        url = citation.get("url")
+        if url and url not in url_to_chunk_index:
+            url_to_chunk_index[url] = len(grounding_chunks)
+            grounding_chunks.append(
+                {"web": {"uri": url, "title": citation.get("title", "")}}
+            )
+
+    # Build grounding supports
+    grounding_supports: list[dict[str, Any]] = []
+
+    for (
+        start_index,
+        end_index,
+        cited_text,
+    ), citations_group in segment_to_citations.items():
+        if start_index is not None and end_index is not None and cited_text:
+            chunk_indices = []
+            confidence_scores = []
+
+            for citation in citations_group:
+                url = citation.get("url")
+                if url and url in url_to_chunk_index:
+                    chunk_indices.append(url_to_chunk_index[url])
+
+                    # Extract confidence scores from extras if available
+                    extras = citation.get("extras", {})
+                    google_metadata = extras.get("google_ai_metadata", {})
+                    scores = google_metadata.get("confidence_scores", [])
+                    confidence_scores.extend(scores)
+
+            support = {
+                "segment": {
+                    "startIndex": start_index,
+                    "endIndex": end_index,
+                    "text": cited_text,
+                },
+                "groundingChunkIndices": chunk_indices,
+            }
+
+            if confidence_scores:
+                support["confidenceScores"] = confidence_scores
+
+            grounding_supports.append(support)
+
+    # Extract search queries from extras if not provided
+    if web_search_queries is None:
+        web_search_queries = []
+        for citation in citations:
+            extras = citation.get("extras", {})
+            google_metadata = extras.get("google_ai_metadata", {})
+            queries = google_metadata.get("web_search_queries", [])
+            web_search_queries.extend(queries)
+        # Remove duplicates while preserving order
+        web_search_queries = list(dict.fromkeys(web_search_queries))
+
+    return {
+        "webSearchQueries": web_search_queries,
+        "groundingChunks": grounding_chunks,
+        "groundingSupports": grounding_supports,
+    }
+
+
+def _convert_from_v1_to_generativelanguage_v1beta(
+    content: list[types.ContentBlock], model_provider: str | None
+) -> list[dict[str, Any]]:
+    """Convert v1 content blocks to `google.ai.generativelanguage_v1beta.types.Content`.
+
+    Args:
+        content: List of v1 `ContentBlock` objects.
+        model_provider: The model provider name that generated the v1 content.
+
+    Returns:
+        List of dictionaries in `google.ai.generativelanguage_v1beta.types.Content`
+        format, ready to be sent to the API.
+    """
+    new_content: list = []
+    for block in content:
+        if not isinstance(block, dict) or "type" not in block:
+            continue
+
+        block_dict = dict(block)  # (For typing)
+
+        # TextContentBlock
+        if block_dict["type"] == "text":
+            new_block = {"text": block_dict.get("text", "")}
+            new_content.append(new_block)
+            # Citations are only handled on output. Can't pass them back :/
+
+        # ReasoningContentBlock -> thinking
+        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 "extras" in block_dict and isinstance(block_dict["extras"], dict):
+                extras = block_dict["extras"]
+                if "signature" in extras:
+                    new_block = {
+                        "thought": True,
+                        "text": block_dict.get("reasoning", ""),
+                        "thought_signature": extras["signature"],
+                    }
+                    new_content.append(new_block)
+                # else: skip reasoning blocks without signatures
+                # TODO: log a warning?
+            # else: skip reasoning blocks without extras
+            # TODO: log a warning?
+
+        # ImageContentBlock
+        elif block_dict["type"] == "image":
+            if base64 := block_dict.get("base64"):
+                new_block = {
+                    "inline_data": {
+                        "mime_type": block_dict.get("mime_type", "image/jpeg"),
+                        "data": base64.encode("utf-8")
+                        if isinstance(base64, str)
+                        else base64,
+                    }
+                }
+                new_content.append(new_block)
+            elif url := block_dict.get("url") and model_provider == "google_genai":
+                # Google file service
+                new_block = {
+                    "file_data": {
+                        "mime_type": block_dict.get("mime_type", "image/jpeg"),
+                        "file_uri": block_dict[str(url)],
+                    }
+                }
+                new_content.append(new_block)
+
+        # TODO: AudioContentBlock -> audio once models support passing back in
+
+        # FileContentBlock (documents)
+        elif block_dict["type"] == "file":
+            if base64 := block_dict.get("base64"):
+                new_block = {
+                    "inline_data": {
+                        "mime_type": block_dict.get(
+                            "mime_type", "application/octet-stream"
+                        ),
+                        "data": base64.encode("utf-8")
+                        if isinstance(base64, str)
+                        else base64,
+                    }
+                }
+                new_content.append(new_block)
+            elif url := block_dict.get("url") and model_provider == "google_genai":
+                # Google file service
+                new_block = {
+                    "file_data": {
+                        "mime_type": block_dict.get(
+                            "mime_type", "application/octet-stream"
+                        ),
+                        "file_uri": block_dict[str(url)],
+                    }
+                }
+                new_content.append(new_block)
+
+        # ToolCall -> FunctionCall
+        elif block_dict["type"] == "tool_call":
+            function_call = {
+                "function_call": {
+                    "name": block_dict.get("name", ""),
+                    "args": block_dict.get("args", {}),
+                }
+            }
+            new_content.append(function_call)
+
+        # ToolCallChunk -> FunctionCall
+        elif block_dict["type"] == "tool_call_chunk":
+            try:
+                args_str = block_dict.get("args") or "{}"
+                input_ = json.loads(args_str) if isinstance(args_str, str) else args_str
+            except json.JSONDecodeError:
+                input_ = {}
+
+            function_call = {
+                "function_call": {
+                    "name": block_dict.get("name", "no_tool_name_present"),
+                    "args": input_,
+                }
+            }
+            new_content.append(function_call)
+
+        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-2.1.12 → langchain_google_genai-3.0.0rc1}/langchain_google_genai/_function_utils.py

@@ -330,8 +330,10 @@ def _get_properties_from_schema(schema: Dict) -> Dict[str, Any]:
             continue
         properties_item: Dict[str, Union[str, int, Dict, List]] = {}
 
-        # Get description from original schema before any modifications
-        description = v.get("description")
+        # Preserve description and other schema properties before manipulation
+        original_description = v.get("description")
+        original_enum = v.get("enum")
+        original_items = v.get("items")
 
         if v.get("anyOf") and all(
             anyOf_type.get("type") != "null" for anyOf_type in v.get("anyOf", [])
@@ -354,11 +356,34 @@ def _get_properties_from_schema(schema: Dict) -> Dict[str, Any]:
             if any_of_types and item_type_ in [glm.Type.ARRAY, glm.Type.OBJECT]:
                 json_type_ = "array" if item_type_ == glm.Type.ARRAY else "object"
                 # Use Index -1 for consistency with `_get_nullable_type_from_schema`
-                v = [val for val in any_of_types if val.get("type") == json_type_][-1]
+                filtered_schema = [
+                    val for val in any_of_types if val.get("type") == json_type_
+                ][-1]
+                # Merge filtered schema with original properties to preserve enum/items
+                v = filtered_schema.copy()
+                if original_enum and not v.get("enum"):
+                    v["enum"] = original_enum
+                if original_items and not v.get("items"):
+                    v["items"] = original_items
+            elif any_of_types:
+                # For other types (like strings with enums), find the non-null schema
+                # and preserve enum/items from the original anyOf structure
+                non_null_schemas = [
+                    val for val in any_of_types if val.get("type") != "null"
+                ]
+                if non_null_schemas:
+                    filtered_schema = non_null_schemas[-1]
+                    v = filtered_schema.copy()
+                    if original_enum and not v.get("enum"):
+                        v["enum"] = original_enum
+                    if original_items and not v.get("items"):
+                        v["items"] = original_items
 
         if v.get("enum"):
             properties_item["enum"] = v["enum"]
 
+        # Prefer description from the filtered schema, fall back to original
+        description = v.get("description") or original_description
         if description and isinstance(description, str):
             properties_item["description"] = description
 
@@ -415,6 +440,8 @@ def _get_items_from_schema(schema: Union[Dict, List, str]) -> Dict[str, Any]:
             items["description"] = (
                 schema.get("description") or schema.get("title") or ""
             )
+        if "enum" in schema:
+            items["enum"] = schema["enum"]
         if _is_nullable_schema(schema):
             items["nullable"] = True
         if "required" in schema:

{langchain_google_genai-2.1.12 → langchain_google_genai-3.0.0rc1}/langchain_google_genai/_genai_extension.py

@@ -632,22 +632,41 @@ def generate_answer(
     )
 
 
-# TODO: Use candidate.finish_message when that field is launched.
-# For now, we derive this message from other existing fields.
 def _get_finish_message(candidate: genai.Candidate) -> str:
+    """Get a human-readable finish message from the candidate.
+
+    Uses the official finish_message field if available, otherwise falls back
+    to a manual mapping of finish reasons to descriptive messages.
+    """
+    # Use the official field when available
+    if hasattr(candidate, "finish_message") and candidate.finish_message:
+        return candidate.finish_message
+
+    # Fallback to manual mapping for all known finish reasons
     finish_messages: Dict[int, str] = {
+        genai.Candidate.FinishReason.STOP: "Generation completed successfully",
         genai.Candidate.FinishReason.MAX_TOKENS: (
             "Maximum token in context window reached"
         ),
         genai.Candidate.FinishReason.SAFETY: "Blocked because of safety",
         genai.Candidate.FinishReason.RECITATION: "Blocked because of recitation",
+        genai.Candidate.FinishReason.LANGUAGE: "Unsupported language detected",
+        genai.Candidate.FinishReason.BLOCKLIST: "Content hit forbidden terms",
+        genai.Candidate.FinishReason.PROHIBITED_CONTENT: (
+            "Inappropriate content detected"
+        ),
+        genai.Candidate.FinishReason.SPII: "Sensitive personal information detected",
+        genai.Candidate.FinishReason.IMAGE_SAFETY: "Image safety violation",
+        genai.Candidate.FinishReason.MALFORMED_FUNCTION_CALL: "Malformed function call",
+        genai.Candidate.FinishReason.UNEXPECTED_TOOL_CALL: "Unexpected tool call",
+        genai.Candidate.FinishReason.OTHER: "Other generation issue",
+        genai.Candidate.FinishReason.FINISH_REASON_UNSPECIFIED: (
+            "Unspecified finish reason"
+        ),
     }
 
     finish_reason = candidate.finish_reason
-    if finish_reason not in finish_messages:
-        return "Unexpected generation error"
-
-    return finish_messages[finish_reason]
+    return finish_messages.get(finish_reason, "Unexpected generation error")
 
 
 def _convert_to_metadata(metadata: Dict[str, Any]) -> List[genai.CustomMetadata]: