langchain-google-genai 2.1.12__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

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/_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/_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/_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]:

langchain_google_genai/chat_models.py

@@ -58,11 +58,16 @@ from google.api_core.exceptions import (
     ResourceExhausted,
     ServiceUnavailable,
 )
+from google.protobuf.json_format import MessageToDict
 from langchain_core.callbacks.manager import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
-from langchain_core.language_models import LangSmithParams, LanguageModelInput
+from langchain_core.language_models import (
+    LangSmithParams,
+    LanguageModelInput,
+    is_openai_data_block,
+)
 from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.messages import (
     AIMessage,
@@ -74,6 +79,7 @@ from langchain_core.messages import (
     ToolMessage,
     is_data_content_block,
 )
+from langchain_core.messages import content as types
 from langchain_core.messages.ai import UsageMetadata, add_usage, subtract_usage
 from langchain_core.messages.tool import invalid_tool_call, tool_call, tool_call_chunk
 from langchain_core.output_parsers import JsonOutputParser, PydanticOutputParser
@@ -110,6 +116,9 @@ from langchain_google_genai._common import (
     _BaseGoogleGenerativeAI,
     get_client_info,
 )
+from langchain_google_genai._compat import (
+    _convert_from_v1_to_generativelanguage_v1beta,
+)
 from langchain_google_genai._function_utils import (
     _dict_to_gapic_schema,
     _tool_choice_to_tool_config,
@@ -287,56 +296,78 @@ async def _achat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
     return await _achat_with_retry(**params)
 
 
-def _is_lc_content_block(part: dict) -> bool:
-    return "type" in part
-
-
-def _is_openai_image_block(block: dict) -> bool:
-    """Check if the block contains image data in OpenAI Chat Completions format."""
-    if block.get("type") == "image_url":
-        if (
-            (set(block.keys()) <= {"type", "image_url", "detail"})
-            and (image_url := block.get("image_url"))
-            and isinstance(image_url, dict)
-        ):
-            url = image_url.get("url")
-            if isinstance(url, str):
-                return True
-    else:
-        return False
-
-    return False
-
-
 def _convert_to_parts(
     raw_content: Union[str, Sequence[Union[str, dict]]],
 ) -> List[Part]:
-    """Converts a list of LangChain messages into a Google parts."""
-    parts = []
+    """Converts LangChain message content into generativelanguage_v1beta parts.
+
+    Used when preparing Human, System and AI messages for sending to the API.
+
+    Handles both legacy (pre-v1) dict-based content blocks and v1 ContentBlock objects.
+    """
     content = [raw_content] if isinstance(raw_content, str) else raw_content
     image_loader = ImageBytesLoader()
+
+    parts = []
+    # Iterate over each item in the content list, constructing a list of Parts
     for part in content:
         if isinstance(part, str):
             parts.append(Part(text=part))
         elif isinstance(part, Mapping):
-            if _is_lc_content_block(part):
+            if "type" in part:
                 if part["type"] == "text":
-                    parts.append(Part(text=part["text"]))
+                    # Either old dict-style CC text block or new TextContentBlock
+                    # Check if there's a signature attached to this text block
+                    thought_sig = None
+                    if "extras" in part and isinstance(part["extras"], dict):
+                        sig = part["extras"].get("signature")
+                        if sig and isinstance(sig, str):
+                            # Decode base64-encoded signature back to bytes
+                            thought_sig = base64.b64decode(sig)
+                    if thought_sig:
+                        parts.append(
+                            Part(text=part["text"], thought_signature=thought_sig)
+                        )
+                    else:
+                        parts.append(Part(text=part["text"]))
                 elif is_data_content_block(part):
-                    if part["source_type"] == "url":
+                    # Handle both legacy LC blocks (with `source_type`) and blocks >= v1
+
+                    if "source_type" in part:
+                        # Catch legacy v0 formats
+                        # Safe since v1 content blocks don't have `source_type` key
+                        if part["source_type"] == "url":
+                            bytes_ = image_loader._bytes_from_url(part["url"])
+                        elif part["source_type"] == "base64":
+                            bytes_ = base64.b64decode(part["data"])
+                        else:
+                            # Unable to support IDContentBlock
+                            msg = "source_type must be url or base64."
+                            raise ValueError(msg)
+                    elif "url" in part:
+                        # v1 multimodal block w/ URL
                         bytes_ = image_loader._bytes_from_url(part["url"])
-                    elif part["source_type"] == "base64":
-                        bytes_ = base64.b64decode(part["data"])
+                    elif "base64" in part:
+                        # v1 multimodal block w/ base64
+                        bytes_ = base64.b64decode(part["base64"])
                     else:
-                        msg = "source_type must be url or base64."
+                        msg = (
+                            "Data content block must contain 'url', 'base64', or "
+                            "'data' field."
+                        )
                         raise ValueError(msg)
                     inline_data: dict = {"data": bytes_}
                     if "mime_type" in part:
                         inline_data["mime_type"] = part["mime_type"]
                     else:
-                        source = cast("str", part.get("url") or part.get("data"))
+                        # Guess mime type based on data field if not provided
+                        source = cast(
+                            "str",
+                            part.get("url") or part.get("base64") or part.get("data"),
+                        )
                         mime_type, _ = mimetypes.guess_type(source)
                         if not mime_type:
+                            # Last resort - try to guess based on file bytes
                             kind = filetype.guess(bytes_)
                             if kind:
                                 mime_type = kind.mime
@@ -344,6 +375,7 @@ def _convert_to_parts(
                             inline_data["mime_type"] = mime_type
                     parts.append(Part(inline_data=inline_data))
                 elif part["type"] == "image_url":
+                    # Chat Completions image format
                     img_url = part["image_url"]
                     if isinstance(img_url, dict):
                         if "url" not in img_url:
@@ -351,9 +383,9 @@ def _convert_to_parts(
                             raise ValueError(msg)
                         img_url = img_url["url"]
                     parts.append(image_loader.load_part(img_url))
-                # Handle media type like LangChain.js
-                # https://github.com/langchain-ai/langchainjs/blob/e536593e2585f1dd7b0afc187de4d07cb40689ba/libs/langchain-google-common/src/utils/gemini.ts#L93-L106
                 elif part["type"] == "media":
+                    # Handle `media` following pattern established in LangChain.js
+                    # https://github.com/langchain-ai/langchainjs/blob/e536593e2585f1dd7b0afc187de4d07cb40689ba/libs/langchain-google-common/src/utils/gemini.ts#L93-L106
                     if "mime_type" not in part:
                         msg = f"Missing mime_type in media part: {part}"
                         raise ValueError(msg)
@@ -361,10 +393,12 @@ def _convert_to_parts(
                     media_part = Part()
 
                     if "data" in part:
+                        # Embedded media
                         media_part.inline_data = Blob(
                             data=part["data"], mime_type=mime_type
                         )
                     elif "file_uri" in part:
+                        # Referenced files (e.g. stored in GCS)
                         media_part.file_data = FileData(
                             file_uri=part["file_uri"], mime_type=mime_type
                         )
@@ -375,7 +409,59 @@ def _convert_to_parts(
                         metadata = VideoMetadata(part["video_metadata"])
                         media_part.video_metadata = metadata
                     parts.append(media_part)
+                elif part["type"] == "function_call_signature":
+                    # Signature for function_call Part - skip it here as it should be
+                    # attached to the actual function_call Part
+                    # This is handled separately in the history parsing logic
+                    pass
+                elif part["type"] == "thinking":
+                    # Pre-existing thinking block format that we continue to store as
+                    thought_sig = None
+                    if "signature" in part:
+                        sig = part["signature"]
+                        if sig and isinstance(sig, str):
+                            # Decode base64-encoded signature back to bytes
+                            thought_sig = base64.b64decode(sig)
+                    parts.append(
+                        Part(
+                            text=part["thinking"],
+                            thought=True,
+                            thought_signature=thought_sig,
+                        )
+                    )
+                elif part["type"] == "reasoning":
+                    # ReasoningContentBlock (when output_version = "v1")
+                    extras = part.get("extras", {}) or {}
+                    sig = extras.get("signature")
+                    thought_sig = None
+                    if sig and isinstance(sig, str):
+                        # Decode base64-encoded signature back to bytes
+                        thought_sig = base64.b64decode(sig)
+                    parts.append(
+                        Part(
+                            text=part["reasoning"],
+                            thought=True,
+                            thought_signature=thought_sig,
+                        )
+                    )
+                elif part["type"] == "server_tool_call":
+                    if part.get("name") == "code_interpreter":
+                        args = part.get("args", {})
+                        code = args.get("code", "")
+                        language = args.get("language", "python")
+                        executable_code_part = Part(
+                            executable_code=ExecutableCode(language=language, code=code)
+                        )
+                        parts.append(executable_code_part)
+                    else:
+                        warnings.warn(
+                            f"Server tool call with name '{part.get('name')}' is not "
+                            "currently supported by Google GenAI. Only "
+                            "'code_interpreter' is supported.",
+                            stacklevel=2,
+                        )
                 elif part["type"] == "executable_code":
+                    # Legacy executable_code format (backward compat)
                     if "executable_code" not in part or "language" not in part:
                         msg = (
                             "Executable code part must have 'code' and 'language' "
@@ -388,7 +474,22 @@ def _convert_to_parts(
                         )
                     )
                     parts.append(executable_code_part)
+                elif part["type"] == "server_tool_result":
+                    output = part.get("output", "")
+                    status = part.get("status", "success")
+                    # Map status to outcome: success → 1 (OUTCOME_OK), error → 2
+                    outcome = 1 if status == "success" else 2
+                    # Check extras for original outcome if available
+                    if "extras" in part and "outcome" in part["extras"]:
+                        outcome = part["extras"]["outcome"]
+                    code_execution_result_part = Part(
+                        code_execution_result=CodeExecutionResult(
+                            output=str(output), outcome=outcome
+                        )
+                    )
+                    parts.append(code_execution_result_part)
                 elif part["type"] == "code_execution_result":
+                    # Legacy code_execution_result format (backward compat)
                     if "code_execution_result" not in part:
                         msg = (
                             "Code execution result part must have "
@@ -406,24 +507,17 @@ def _convert_to_parts(
                         )
                     )
                     parts.append(code_execution_result_part)
-                elif part["type"] == "thinking":
-                    parts.append(Part(text=part["thinking"], thought=True))
                 else:
-                    msg = (
-                        f"Unrecognized message part type: {part['type']}. Only text, "
-                        f"image_url, and media types are supported."
-                    )
+                    msg = f"Unrecognized message part type: {part['type']}."
                     raise ValueError(msg)
             else:
-                # Yolo
+                # Yolo. The input message content doesn't have a `type` key
                 logger.warning(
                     "Unrecognized message part format. Assuming it's a text part."
                 )
                 parts.append(Part(text=str(part)))
         else:
-            # TODO: Maybe some of Google's native stuff
-            # would hit this branch.
-            msg = "Gemini only supports text and inline_data parts."
+            msg = "Unknown error occurred while converting LC message content to parts."
             raise ChatGoogleGenerativeAIError(msg)
     return parts
 
@@ -441,7 +535,7 @@ def _convert_tool_message_to_parts(
         other_blocks = []
         for block in message.content:
             if isinstance(block, dict) and (
-                is_data_content_block(block) or _is_openai_image_block(block)
+                is_data_content_block(block) or is_openai_data_block(block)
             ):
                 media_blocks.append(block)
             else:
@@ -496,7 +590,20 @@ def _get_ai_message_tool_messages_parts(
 def _parse_chat_history(
     input_messages: Sequence[BaseMessage], convert_system_message_to_human: bool = False
 ) -> Tuple[Optional[Content], List[Content]]:
-    messages: List[Content] = []
+    """Parses sequence of `BaseMessage` into system instruction and formatted messages.
+
+    Args:
+        input_messages: Sequence of `BaseMessage` objects representing the chat history.
+        convert_system_message_to_human: Whether to convert the first system message
+            into a human message. Deprecated, use system instructions instead.
+
+    Returns:
+        A tuple containing:
+        - An optional `google.ai.generativelanguage_v1beta.types.Content` representing
+            the system instruction (if any).
+        - A list of `google.ai.generativelanguage_v1beta.types.Content` representing the
+            formatted messages.
+    """
 
     if convert_system_message_to_human:
         warnings.warn(
@@ -505,6 +612,28 @@ def _parse_chat_history(
             DeprecationWarning,
             stacklevel=2,
         )
+    input_messages = list(input_messages)  # Make a mutable copy
+
+    # Case where content was serialized to v1 format
+    for idx, message in enumerate(input_messages):
+        if (
+            isinstance(message, AIMessage)
+            and message.response_metadata.get("output_version") == "v1"
+        ):
+            # Unpack known v1 content to v1beta format for the request
+            #
+            # Old content types and any previously serialized messages passed back in to
+            # history will skip this, but hit and processed in `_convert_to_parts`
+            input_messages[idx] = message.model_copy(
+                update={
+                    "content": _convert_from_v1_to_generativelanguage_v1beta(
+                        cast(list[types.ContentBlock], message.content),
+                        message.response_metadata.get("model_provider"),
+                    )
+                }
+            )
+
+    formatted_messages: List[Content] = []
 
     system_instruction: Optional[Content] = None
     messages_without_tool_messages = [
@@ -527,19 +656,43 @@ def _parse_chat_history(
             role = "model"
             if message.tool_calls:
                 ai_message_parts = []
-                for tool_call in message.tool_calls:
+                # Extract any function_call_signature blocks from content
+                function_call_sigs: dict[int, bytes] = {}
+                if isinstance(message.content, list):
+                    for idx, item in enumerate(message.content):
+                        if (
+                            isinstance(item, dict)
+                            and item.get("type") == "function_call_signature"
+                        ):
+                            sig_str = item.get("signature", "")
+                            if sig_str and isinstance(sig_str, str):
+                                # Decode base64-encoded signature back to bytes
+                                sig_bytes = base64.b64decode(sig_str)
+                                function_call_sigs[idx] = sig_bytes
+
+                for tool_call_idx, tool_call in enumerate(message.tool_calls):
                     function_call = FunctionCall(
                         {
                             "name": tool_call["name"],
                             "args": tool_call["args"],
                         }
                     )
-                    ai_message_parts.append(Part(function_call=function_call))
+                    # Check if there's a signature for this function call
+                    # (We use the index to match signature to function call)
+                    sig = function_call_sigs.get(tool_call_idx)
+                    if sig:
+                        ai_message_parts.append(
+                            Part(function_call=function_call, thought_signature=sig)
+                        )
+                    else:
+                        ai_message_parts.append(Part(function_call=function_call))
                 tool_messages_parts = _get_ai_message_tool_messages_parts(
                     tool_messages=tool_messages, ai_message=message
                 )
-                messages.append(Content(role=role, parts=ai_message_parts))
-                messages.append(Content(role="user", parts=tool_messages_parts))
+                formatted_messages.append(Content(role=role, parts=ai_message_parts))
+                formatted_messages.append(
+                    Content(role="user", parts=tool_messages_parts)
+                )
                 continue
             if raw_function_call := message.additional_kwargs.get("function_call"):
                 function_call = FunctionCall(
@@ -550,7 +703,12 @@ def _parse_chat_history(
                 )
                 parts = [Part(function_call=function_call)]
             else:
-                parts = _convert_to_parts(message.content)
+                if message.response_metadata.get("output_version") == "v1":
+                    # Already converted to v1beta format above
+                    parts = message.content  # type: ignore[assignment]
+                else:
+                    # Prepare request content parts from message.content field
+                    parts = _convert_to_parts(message.content)
         elif isinstance(message, HumanMessage):
             role = "user"
             parts = _convert_to_parts(message.content)
@@ -564,8 +722,11 @@ def _parse_chat_history(
             msg = f"Unexpected message with type {type(message)} at the position {i}."
             raise ValueError(msg)
 
-        messages.append(Content(role=role, parts=parts))
-    return system_instruction, messages
+        # Final step; assemble the Content object to pass to the API
+        # If version = "v1", the parts are already in v1beta format and will be
+        # automatically converted using protobuf's auto-conversion
+        formatted_messages.append(Content(role=role, parts=parts))
+    return system_instruction, formatted_messages
 
 
 # Helper function to append content consistently
@@ -589,13 +750,20 @@ def _append_to_content(
 
 
 def _parse_response_candidate(
-    response_candidate: Candidate, streaming: bool = False
+    response_candidate: Candidate,
+    streaming: bool = False,
+    model_name: Optional[str] = None,
 ) -> AIMessage:
     content: Union[None, str, List[Union[str, dict]]] = None
     additional_kwargs: Dict[str, Any] = {}
+    response_metadata: Dict[str, Any] = {"model_provider": "google_genai"}
+    if model_name:
+        response_metadata["model_name"] = model_name
     tool_calls = []
     invalid_tool_calls = []
     tool_call_chunks = []
+    # Track function call signatures separately to handle them conditionally
+    function_call_signatures: List[dict] = []
 
     for part in response_candidate.content.parts:
         text: Optional[str] = None
@@ -608,21 +776,49 @@ def _parse_response_candidate(
         except AttributeError:
             pass
 
+        # Extract thought signature if present (can be on any Part type)
+        # Signatures are binary data, encode to base64 string for JSON serialization
+        thought_sig: Optional[str] = None
+        if hasattr(part, "thought_signature") and part.thought_signature:
+            try:
+                # Encode binary signature to base64 string
+                thought_sig = base64.b64encode(part.thought_signature).decode("ascii")
+                if not thought_sig:  # Empty string
+                    thought_sig = None
+            except (AttributeError, TypeError):
+                thought_sig = None
+
         if hasattr(part, "thought") and part.thought:
             thinking_message = {
                 "type": "thinking",
                 "thinking": part.text,
             }
+            # Include signature if present
+            if thought_sig:
+                thinking_message["signature"] = thought_sig
             content = _append_to_content(content, thinking_message)
         elif text is not None and text:
-            content = _append_to_content(content, text)
+            # Check if this text Part has a signature attached
+            if thought_sig:
+                # Text with signature needs structured block to preserve signature
+                # We use a v1 TextContentBlock
+                text_with_sig = {
+                    "type": "text",
+                    "text": text,
+                    "extras": {"signature": thought_sig},
+                }
+                content = _append_to_content(content, text_with_sig)
+            else:
+                content = _append_to_content(content, text)
 
         if hasattr(part, "executable_code") and part.executable_code is not None:
             if part.executable_code.code and part.executable_code.language:
+                code_id = str(uuid.uuid4())  # Generate ID if not present, needed later
                 code_message = {
                     "type": "executable_code",
                     "executable_code": part.executable_code.code,
                     "language": part.executable_code.language,
+                    "id": code_id,
                 }
                 content = _append_to_content(content, code_message)
 
@@ -630,14 +826,21 @@ def _parse_response_candidate(
             hasattr(part, "code_execution_result")
             and part.code_execution_result is not None
         ) and part.code_execution_result.output:
+            # outcome: 1 = OUTCOME_OK (success), else = error
+            outcome = part.code_execution_result.outcome
             execution_result = {
                 "type": "code_execution_result",
                 "code_execution_result": part.code_execution_result.output,
-                "outcome": part.code_execution_result.outcome,
+                "outcome": outcome,
+                "tool_call_id": "",  # Linked via block translator
             }
             content = _append_to_content(content, execution_result)
 
-        if part.inline_data.mime_type.startswith("audio/"):
+        if (
+            hasattr(part, "inline_data")
+            and part.inline_data
+            and part.inline_data.mime_type.startswith("audio/")
+        ):
             buffer = io.BytesIO()
 
             with wave.open(buffer, "wb") as wf:
@@ -647,9 +850,17 @@ def _parse_response_candidate(
                 wf.setframerate(24000)
                 wf.writeframes(part.inline_data.data)
 
-            additional_kwargs["audio"] = buffer.getvalue()
+            audio_data = buffer.getvalue()
+            additional_kwargs["audio"] = audio_data
+
+            # For backwards compatibility, audio stays in additional_kwargs by default
+            # and is accessible via .content_blocks property
 
-        if part.inline_data.mime_type.startswith("image/"):
+        if (
+            hasattr(part, "inline_data")
+            and part.inline_data
+            and part.inline_data.mime_type.startswith("image/")
+        ):
             image_format = part.inline_data.mime_type[6:]
             image_message = {
                 "type": "image_url",
@@ -708,6 +919,23 @@ def _parse_response_candidate(
                             id=tool_call_dict.get("id", str(uuid.uuid4())),
                         )
                     )
+
+            # If this function_call Part has a signature, track it separately
+            # We'll add it to content only if there's other content present
+            if thought_sig:
+                sig_block = {
+                    "type": "function_call_signature",
+                    "signature": thought_sig,
+                }
+                function_call_signatures.append(sig_block)
+
+    # Add function call signatures to content only if there's already other content
+    # This preserves backward compatibility where content is "" for
+    # function-only responses
+    if function_call_signatures and content is not None:
+        for sig_block in function_call_signatures:
+            content = _append_to_content(content, sig_block)
+
     if content is None:
         content = ""
     if isinstance(content, list) and any(
@@ -722,22 +950,100 @@ def _parse_response_candidate(
         Validate before using in production.
 """
         )
-
     if streaming:
         return AIMessageChunk(
             content=content,
             additional_kwargs=additional_kwargs,
+            response_metadata=response_metadata,
             tool_call_chunks=tool_call_chunks,
         )
 
     return AIMessage(
         content=content,
         additional_kwargs=additional_kwargs,
+        response_metadata=response_metadata,
         tool_calls=tool_calls,
         invalid_tool_calls=invalid_tool_calls,
     )
 
 
+def _extract_grounding_metadata(candidate: Any) -> Dict[str, Any]:
+    """Extract grounding metadata from candidate.
+
+    core's block translator converts this metadata into citation annotations.
+
+    Uses `MessageToDict` for complete unfiltered extraction.
+
+    Falls back to custom field extraction in cases of failure for robustness.
+    """
+    if not hasattr(candidate, "grounding_metadata") or not candidate.grounding_metadata:
+        return {}
+
+    grounding_metadata = candidate.grounding_metadata
+
+    try:
+        # proto-plus wraps protobuf messages - access ._pb to get the raw protobuf
+        # message that MessageToDict expects
+        pb_message = (
+            grounding_metadata._pb
+            if hasattr(grounding_metadata, "_pb")
+            else grounding_metadata
+        )
+
+        return MessageToDict(  # type: ignore[call-arg]
+            pb_message,
+            preserving_proto_field_name=True,
+            always_print_fields_with_no_presence=True,
+            # type stub issue - ensures that protobuf fields with default values
+            # (like start_index=0) are included in the output
+        )
+    except (AttributeError, TypeError, ImportError):
+        # Attempt manual extraction of known fields
+        result: Dict[str, Any] = {}
+
+        # Grounding chunks
+        if hasattr(grounding_metadata, "grounding_chunks"):
+            grounding_chunks = []
+            for chunk in grounding_metadata.grounding_chunks:
+                chunk_data: Dict[str, Any] = {}
+                if hasattr(chunk, "web") and chunk.web:
+                    chunk_data["web"] = {
+                        "uri": chunk.web.uri if hasattr(chunk.web, "uri") else "",
+                        "title": chunk.web.title if hasattr(chunk.web, "title") else "",
+                    }
+                grounding_chunks.append(chunk_data)
+            result["grounding_chunks"] = grounding_chunks
+
+        # Grounding supports
+        if hasattr(grounding_metadata, "grounding_supports"):
+            grounding_supports = []
+            for support in grounding_metadata.grounding_supports:
+                support_data: Dict[str, Any] = {}
+                if hasattr(support, "segment") and support.segment:
+                    support_data["segment"] = {
+                        "start_index": getattr(support.segment, "start_index", 0),
+                        "end_index": getattr(support.segment, "end_index", 0),
+                        "text": getattr(support.segment, "text", ""),
+                        "part_index": getattr(support.segment, "part_index", 0),
+                    }
+                if hasattr(support, "grounding_chunk_indices"):
+                    support_data["grounding_chunk_indices"] = list(
+                        support.grounding_chunk_indices
+                    )
+                if hasattr(support, "confidence_scores"):
+                    support_data["confidence_scores"] = [
+                        round(score, 6) for score in support.confidence_scores
+                    ]
+                grounding_supports.append(support_data)
+            result["grounding_supports"] = grounding_supports
+
+        # Web search queries
+        if hasattr(grounding_metadata, "web_search_queries"):
+            result["web_search_queries"] = list(grounding_metadata.web_search_queries)
+
+        return result
+
+
 def _response_to_result(
     response: GenerateContentResponse,
     stream: bool = False,
@@ -800,15 +1106,16 @@ def _response_to_result(
             proto.Message.to_dict(safety_rating, use_integers_for_enums=False)
             for safety_rating in candidate.safety_ratings
         ]
-        try:
-            if candidate.grounding_metadata:
-                generation_info["grounding_metadata"] = proto.Message.to_dict(
-                    candidate.grounding_metadata
-                )
-        except AttributeError:
-            pass
+        grounding_metadata = _extract_grounding_metadata(candidate)
+        generation_info["grounding_metadata"] = grounding_metadata
         message = _parse_response_candidate(candidate, streaming=stream)
+
         message.usage_metadata = lc_usage
+
+        if not hasattr(message, "response_metadata"):
+            message.response_metadata = {}
+        message.response_metadata["grounding_metadata"] = grounding_metadata
+
         if stream:
             generations.append(
                 ChatGenerationChunk(
@@ -1054,7 +1361,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 file = client.files.get(name=file.name)
 
             # Create cache
-            model = "models/gemini-1.5-flash-latest"
+            model = "models/gemini-2.5-flash"
             cache = client.caches.create(
                 model=model,
                 config=types.CreateCachedContentConfig(
@@ -1110,7 +1417,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                     ],
                 )
             ]
-            model = "gemini-1.5-flash-latest"
+            model = "gemini-2.5-flash"
             cache = client.caches.create(
                 model=model,
                 config=CreateCachedContentConfig(
@@ -1216,8 +1523,12 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 )
 
 
+            # Default method uses function calling
             structured_llm = llm.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats")
+
+            # For more reliable output, use json_schema with native responseSchema
+            structured_llm_json = llm.with_structured_output(Joke, method="json_schema")
+            structured_llm_json.invoke("Tell me a joke about cats")
 
         .. code-block:: python
 
@@ -1227,6 +1538,18 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 rating=None,
             )
 
+        Two methods are supported for structured output:
+
+        * ``method="function_calling"`` (default): Uses tool calling to extract
+        structured data. Compatible with all models.
+        * ``method="json_schema"``: Uses Gemini's native structured output with
+        responseSchema. More reliable but requires Gemini 1.5+ models.
+        ``method="json_mode"`` also works for backwards compatibility but is a misnomer.
+
+        The ``json_schema`` method is recommended for better reliability as it
+        constrains the model's generation process directly rather than relying on
+        post-processing tool calls.
+
     Image input:
         .. code-block:: python
 
@@ -1649,12 +1972,12 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         code_execution: Optional[bool] = None,
         stop: Optional[list[str]] = None,
         **kwargs: Any,
-    ) -> BaseMessage:
-        """Enable code execution. Supported on: gemini-1.5-pro, gemini-1.5-flash,
-        gemini-2.0-flash, and gemini-2.0-pro. When enabled, the model can execute
-        code to solve problems.
+    ) -> AIMessage:
+        """Override invoke to add code_execution parameter.
+
+        Supported on: gemini-1.5-pro, gemini-1.5-flash, gemini-2.0-flash, and
+        gemini-2.0-pro. When enabled, the model can execute code to solve problems.
         """
-        """Override invoke to add code_execution parameter."""
 
         if code_execution is not None:
             if not self._supports_code_execution:
@@ -2053,7 +2376,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             ]
         request = GenerateContentRequest(
             model=self.model,
-            contents=history,
+            contents=history,  # google.ai.generativelanguage_v1beta.types.Content
             tools=formatted_tools,
             tool_config=formatted_tool_config,
             safety_settings=formatted_safety_settings,
@@ -2070,7 +2393,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         return request
 
     def get_num_tokens(self, text: str) -> int:
-        """Get the number of tokens present in the text.
+        """Get the number of tokens present in the text. Uses the model's tokenizer.
 
         Useful for checking if an input will fit in a model's context window.
 
@@ -2088,7 +2411,9 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     def with_structured_output(
         self,
         schema: Union[Dict, Type[BaseModel]],
-        method: Optional[Literal["function_calling", "json_mode"]] = "function_calling",
+        method: Optional[
+            Literal["function_calling", "json_mode", "json_schema"]
+        ] = "function_calling",
         *,
         include_raw: bool = False,
         **kwargs: Any,
@@ -2100,7 +2425,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
         parser: OutputParserLike
 
-        if method == "json_mode":
+        # `json_schema` preferred, but `json_mode` kept for backwards compatibility
+        if method in ("json_mode", "json_schema"):
             if isinstance(schema, type) and is_basemodel_subclass(schema):
                 if issubclass(schema, BaseModelV1):
                     schema_json = schema.schema()
@@ -2168,7 +2494,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         *,
         tool_choice: Optional[Union[_ToolChoiceType, bool]] = None,
         **kwargs: Any,
-    ) -> Runnable[LanguageModelInput, BaseMessage]:
+    ) -> Runnable[LanguageModelInput, AIMessage]:
         """Bind tool-like objects to this chat model.
 
         Assumes model is compatible with google-generativeAI tool-calling API.

langchain_google_genai/embeddings.py

@@ -116,22 +116,10 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
             client_options=self.client_options,
             transport=self.transport,
         )
-        # Only initialize async client if there's an event loop running
-        # to avoid RuntimeError during synchronous initialization
-        if _is_event_loop_running():
-            # async clients don't support "rest" transport
-            transport = self.transport
-            if transport == "rest":
-                transport = "grpc_asyncio"
-            self.async_client = build_generative_async_service(
-                credentials=self.credentials,
-                api_key=google_api_key,
-                client_info=client_info,
-                client_options=self.client_options,
-                transport=transport,
-            )
-        else:
-            self.async_client = None
+        # Always defer async client initialization to first async call.
+        # Avoids implicit event loop creation and aligns with lazy init
+        # in chat models.
+        self.async_client = None
         return self
 
     @property

{langchain_google_genai-2.1.12.dist-info → langchain_google_genai-3.0.0rc1.dist-info}/METADATA

@@ -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-3.0.0rc1.dist-info/RECORD

@@ -0,0 +1,18 @@
+langchain_google_genai-3.0.0rc1.dist-info/METADATA,sha256=6JdNfUOyd0HYZ-nULDv_tXw0opP9bYVv31J4PwAO1Hc,7098
+langchain_google_genai-3.0.0rc1.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+langchain_google_genai-3.0.0rc1.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+langchain_google_genai-3.0.0rc1.dist-info/licenses/LICENSE,sha256=DppmdYJVSc1jd0aio6ptnMUn5tIHrdAhQ12SclEBfBg,1072
+langchain_google_genai/__init__.py,sha256=yVc4wCHzajs8mvDVQLGmkxxivzApvdu7jTytrLr_i7g,2891
+langchain_google_genai/_common.py,sha256=qV7EqGEsi1_BCnUDJf1ZDgOhHOIGKbgw8-D1g7Afo3g,6307
+langchain_google_genai/_compat.py,sha256=QGQhorN0DHpbXMVJyKlzYdNz62L8EU6XM9EK-kfg-rQ,10979
+langchain_google_genai/_enums.py,sha256=Zj3BXXLlkm_UybegCi6fLsfFhriJCt_LAJvgatgPWQ0,252
+langchain_google_genai/_function_utils.py,sha256=zlH0YhFZolP6mhppBPr-7d1t6psvZcpSmkuS1oER0S0,23647
+langchain_google_genai/_genai_extension.py,sha256=3W8N_vMxrwtzZvmPgmyIr6T8q6UkyS3y-IYMcr_67Ac,22597
+langchain_google_genai/_image_utils.py,sha256=iJ3KrFWQhA0UwsT8ryAFAmNM7-_2ahHAppT8t9WFZGQ,5304
+langchain_google_genai/chat_models.py,sha256=jVeoq3r1ekE2KXQmbEalLaMgAFxXATB3i1HDz4S1zDI,101386
+langchain_google_genai/embeddings.py,sha256=MF_AoQNVhWJ6ekH6NPfZ_UGk_ixL-BX05gvZtcjYpEo,16193
+langchain_google_genai/genai_aqa.py,sha256=NVW8wOWxU7T6VVshFrFlFHa5HzEPAedrgh1fOwFH7Og,4380
+langchain_google_genai/google_vector_store.py,sha256=x4OcXkcYWTubu-AESNzNDJG_dbge16GeNCAOCsBoc4g,16537
+langchain_google_genai/llms.py,sha256=P_e_ImBWexhKqc7LZPo6tQbwLH2-ljr6oqpE5M27TRc,5755
+langchain_google_genai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_google_genai-3.0.0rc1.dist-info/RECORD,,

langchain_google_genai-2.1.12.dist-info/RECORD

@@ -1,17 +0,0 @@
-langchain_google_genai-2.1.12.dist-info/METADATA,sha256=cIpzlJRZXFdHG-aZmSE6MJUmSr-JAZzH7pDvU30nzOs,7051
-langchain_google_genai-2.1.12.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-langchain_google_genai-2.1.12.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-langchain_google_genai-2.1.12.dist-info/licenses/LICENSE,sha256=DppmdYJVSc1jd0aio6ptnMUn5tIHrdAhQ12SclEBfBg,1072
-langchain_google_genai/__init__.py,sha256=yVc4wCHzajs8mvDVQLGmkxxivzApvdu7jTytrLr_i7g,2891
-langchain_google_genai/_common.py,sha256=dzzcJeDVnUUI_8Y20F40SZ5NjW6RHD4xJu74naYK58k,6192
-langchain_google_genai/_enums.py,sha256=Zj3BXXLlkm_UybegCi6fLsfFhriJCt_LAJvgatgPWQ0,252
-langchain_google_genai/_function_utils.py,sha256=Pur365t4M8O5dkrnFkDc_jHiPfuI_C7ucSxvxA3tioM,22254
-langchain_google_genai/_genai_extension.py,sha256=LiNa7b6BZp41meJMtgaSEbaGJa59BY3UMCRMHO_CCtQ,21467
-langchain_google_genai/_image_utils.py,sha256=iJ3KrFWQhA0UwsT8ryAFAmNM7-_2ahHAppT8t9WFZGQ,5304
-langchain_google_genai/chat_models.py,sha256=G619buVU9Sef33Ubk9JL8gYLd5y_jsGMgFXeuPq7wJ0,85067
-langchain_google_genai/embeddings.py,sha256=Kar6nHpAJ0rWQZ0nc7_anWETlwCIovd4DhieIviGNQ8,16687
-langchain_google_genai/genai_aqa.py,sha256=NVW8wOWxU7T6VVshFrFlFHa5HzEPAedrgh1fOwFH7Og,4380
-langchain_google_genai/google_vector_store.py,sha256=x4OcXkcYWTubu-AESNzNDJG_dbge16GeNCAOCsBoc4g,16537
-langchain_google_genai/llms.py,sha256=P_e_ImBWexhKqc7LZPo6tQbwLH2-ljr6oqpE5M27TRc,5755
-langchain_google_genai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_google_genai-2.1.12.dist-info/RECORD,,