lfx-google 0.1.0__py3-none-any.whl

lfx_google/__init__.py

@@ -0,0 +1,25 @@
+"""Google and Gemini components for Langflow."""
+
+from lfx_google.components.google import (
+    BigQueryExecutorComponent,
+    GmailLoaderComponent,
+    GoogleDriveComponent,
+    GoogleDriveSearchComponent,
+    GoogleGenerativeAIComponent,
+    GoogleGenerativeAIEmbeddingsComponent,
+    GoogleOAuthToken,
+    GoogleSearchAPICore,
+    GoogleSerperAPICore,
+)
+
+__all__ = [
+    "BigQueryExecutorComponent",
+    "GmailLoaderComponent",
+    "GoogleDriveComponent",
+    "GoogleDriveSearchComponent",
+    "GoogleGenerativeAIComponent",
+    "GoogleGenerativeAIEmbeddingsComponent",
+    "GoogleOAuthToken",
+    "GoogleSearchAPICore",
+    "GoogleSerperAPICore",
+]

lfx_google/components/__init__.py

@@ -0,0 +1 @@
+"""Component packages shipped by lfx-google."""

lfx_google/components/google/__init__.py

@@ -0,0 +1,21 @@
+from .gmail import GmailLoaderComponent
+from .google_bq_sql_executor import BigQueryExecutorComponent
+from .google_drive import GoogleDriveComponent
+from .google_drive_search import GoogleDriveSearchComponent
+from .google_generative_ai import GoogleGenerativeAIComponent
+from .google_generative_ai_embeddings import GoogleGenerativeAIEmbeddingsComponent
+from .google_oauth_token import GoogleOAuthToken
+from .google_search_api_core import GoogleSearchAPICore
+from .google_serper_api_core import GoogleSerperAPICore
+
+__all__ = [
+    "BigQueryExecutorComponent",
+    "GmailLoaderComponent",
+    "GoogleDriveComponent",
+    "GoogleDriveSearchComponent",
+    "GoogleGenerativeAIComponent",
+    "GoogleGenerativeAIEmbeddingsComponent",
+    "GoogleOAuthToken",
+    "GoogleSearchAPICore",
+    "GoogleSerperAPICore",
+]

lfx_google/components/google/gmail.py

@@ -0,0 +1,196 @@
+import base64
+import json
+import re
+from collections.abc import Iterator
+from json.decoder import JSONDecodeError
+from typing import Any
+
+from google.auth.exceptions import RefreshError
+from google.oauth2.credentials import Credentials
+from googleapiclient.discovery import build
+from langchain_core.chat_sessions import ChatSession
+from langchain_core.messages import HumanMessage
+from langchain_google_community.gmail.loader import GMailLoader
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import MessageTextInput
+from lfx.io import SecretStrInput
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.template.field.base import Output
+
+
+class GmailLoaderComponent(Component):
+    display_name = "Gmail Loader"
+    description = "Loads emails from Gmail using provided credentials."
+    icon = "Google"
+    legacy: bool = True
+    replacement = ["composio.ComposioGmailAPIComponent"]
+
+    inputs = [
+        SecretStrInput(
+            name="json_string",
+            display_name="JSON String of the Service Account Token",
+            info="JSON string containing OAuth 2.0 access token information for service account access",
+            required=True,
+            value="""{
+                "account": "",
+                "client_id": "",
+                "client_secret": "",
+                "expiry": "",
+                "refresh_token": "",
+                "scopes": [
+                    "https://www.googleapis.com/auth/gmail.readonly",
+                ],
+                "token": "",
+                "token_uri": "https://oauth2.googleapis.com/token",
+                "universe_domain": "googleapis.com"
+            }""",
+        ),
+        MessageTextInput(
+            name="label_ids",
+            display_name="Label IDs",
+            info="Comma-separated list of label IDs to filter emails.",
+            required=True,
+            value="INBOX,SENT,UNREAD,IMPORTANT",
+        ),
+        MessageTextInput(
+            name="max_results",
+            display_name="Max Results",
+            info="Maximum number of emails to load.",
+            required=True,
+            value="10",
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="JSON", name="data", method="load_emails"),
+    ]
+
+    def load_emails(self) -> Data:
+        class CustomGMailLoader(GMailLoader):
+            def __init__(
+                self, creds: Any, *, n: int = 100, label_ids: list[str] | None = None, raise_error: bool = False
+            ) -> None:
+                super().__init__(creds, n, raise_error)
+                self.label_ids = label_ids if label_ids is not None else ["SENT"]
+
+            def clean_message_content(self, message):
+                # Remove URLs
+                message = re.sub(r"http\S+|www\S+|https\S+", "", message, flags=re.MULTILINE)
+
+                # Remove email addresses
+                message = re.sub(r"\S+@\S+", "", message)
+
+                # Remove special characters and excessive whitespace
+                message = re.sub(r"[^A-Za-z0-9\s]+", " ", message)
+                message = re.sub(r"\s{2,}", " ", message)
+
+                # Trim leading and trailing whitespace
+                return message.strip()
+
+            def _extract_email_content(self, msg: Any) -> HumanMessage:
+                from_email = None
+                for values in msg["payload"]["headers"]:
+                    name = values["name"]
+                    if name == "From":
+                        from_email = values["value"]
+                if from_email is None:
+                    msg = "From email not found."
+                    raise ValueError(msg)
+
+                parts = msg["payload"]["parts"] if "parts" in msg["payload"] else [msg["payload"]]
+
+                for part in parts:
+                    if part["mimeType"] == "text/plain":
+                        data = part["body"]["data"]
+                        data = base64.urlsafe_b64decode(data).decode("utf-8")
+                        pattern = re.compile(r"\r\nOn .+(\r\n)*wrote:\r\n")
+                        newest_response = re.split(pattern, data)[0]
+                        return HumanMessage(
+                            content=self.clean_message_content(newest_response),
+                            additional_kwargs={"sender": from_email},
+                        )
+                msg = "No plain text part found in the email."
+                raise ValueError(msg)
+
+            def _get_message_data(self, service: Any, message: Any) -> ChatSession:
+                msg = service.users().messages().get(userId="me", id=message["id"]).execute()
+                message_content = self._extract_email_content(msg)
+
+                in_reply_to = None
+                email_data = msg["payload"]["headers"]
+                for values in email_data:
+                    name = values["name"]
+                    if name == "In-Reply-To":
+                        in_reply_to = values["value"]
+
+                thread_id = msg["threadId"]
+
+                if in_reply_to:
+                    thread = service.users().threads().get(userId="me", id=thread_id).execute()
+                    messages = thread["messages"]
+
+                    response_email = None
+                    for _message in messages:
+                        email_data = _message["payload"]["headers"]
+                        for values in email_data:
+                            if values["name"] == "Message-ID":
+                                message_id = values["value"]
+                                if message_id == in_reply_to:
+                                    response_email = _message
+                    if response_email is None:
+                        msg = "Response email not found in the thread."
+                        raise ValueError(msg)
+                    starter_content = self._extract_email_content(response_email)
+                    return ChatSession(messages=[starter_content, message_content])
+                return ChatSession(messages=[message_content])
+
+            def lazy_load(self) -> Iterator[ChatSession]:
+                service = build("gmail", "v1", credentials=self.creds)
+                results = (
+                    service.users().messages().list(userId="me", labelIds=self.label_ids, maxResults=self.n).execute()
+                )
+                messages = results.get("messages", [])
+                if not messages:
+                    logger.warning("No messages found with the specified labels.")
+                for message in messages:
+                    try:
+                        yield self._get_message_data(service, message)
+                    except Exception:
+                        if self.raise_error:
+                            raise
+                        else:
+                            logger.exception(f"Error processing message {message['id']}")
+
+        json_string = self.json_string
+        label_ids = self.label_ids.split(",") if self.label_ids else ["INBOX"]
+        try:
+            max_results = int(self.max_results) if self.max_results else 100
+        except (TypeError, ValueError) as e:
+            msg = f"Invalid max_results value: {self.max_results}"
+            raise ValueError(msg) from e
+
+        # Load the token information from the JSON string
+        try:
+            token_info = json.loads(json_string)
+        except JSONDecodeError as e:
+            msg = "Invalid JSON string"
+            raise ValueError(msg) from e
+
+        creds = Credentials.from_authorized_user_info(token_info)
+
+        # Initialize the custom loader with the provided credentials
+        loader = CustomGMailLoader(creds=creds, n=max_results, label_ids=label_ids)
+
+        try:
+            docs = loader.load()
+        except RefreshError as e:
+            msg = "Authentication error: Unable to refresh authentication token. Please try to reauthenticate."
+            raise ValueError(msg) from e
+        except Exception as e:
+            msg = f"Error loading documents: {e}"
+            raise ValueError(msg) from e
+
+        # Return the loaded documents
+        self.status = docs
+        return Data(data={"text": docs})

lfx_google/components/google/google_bq_sql_executor.py

@@ -0,0 +1,156 @@
+import json
+import re
+from pathlib import Path
+
+from google.auth.exceptions import RefreshError
+from google.cloud import bigquery
+from google.oauth2.service_account import Credentials
+from lfx.custom import Component
+from lfx.io import BoolInput, FileInput, MessageTextInput, Output
+from lfx.schema.dataframe import DataFrame
+
+
+class BigQueryExecutorComponent(Component):
+    display_name = "BigQuery"
+    description = "Execute SQL queries on Google BigQuery."
+    name = "BigQueryExecutor"
+    icon = "Google"
+    beta: bool = True
+
+    inputs = [
+        FileInput(
+            name="service_account_json_file",
+            display_name="Upload Service Account JSON",
+            info="Upload the JSON file containing Google Cloud service account credentials.",
+            file_types=["json"],
+            required=True,
+        ),
+        MessageTextInput(
+            name="query",
+            display_name="SQL Query",
+            info="The SQL query to execute on BigQuery.",
+            required=True,
+            tool_mode=True,
+        ),
+        BoolInput(
+            name="clean_query",
+            display_name="Clean Query",
+            info="When enabled, this will automatically clean up your SQL query.",
+            value=False,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Query Results", name="query_results", method="execute_sql"),
+    ]
+
+    def _clean_sql_query(self, query: str) -> str:
+        """Clean SQL query by removing surrounding quotes and whitespace.
+
+        Also extracts SQL statements from text that might contain other content.
+
+        Args:
+            query: The SQL query to clean
+
+        Returns:
+            The cleaned SQL query
+        """
+        # First, try to extract SQL from code blocks
+        sql_pattern = r"```(?:sql)?\s*([\s\S]*?)\s*```"
+        sql_matches = re.findall(sql_pattern, query, re.IGNORECASE)
+
+        if sql_matches:
+            # If we found SQL in code blocks, use the first match
+            query = sql_matches[0]
+        else:
+            # If no code block, try to find SQL statements
+            # Look for common SQL keywords at the start of lines
+            sql_keywords = r"(?i)(SELECT|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP|WITH|MERGE)"
+            lines = query.split("\n")
+            sql_lines = []
+            in_sql = False
+
+            for _line in lines:
+                line = _line.strip()
+                if re.match(sql_keywords, line):
+                    in_sql = True
+                if in_sql:
+                    sql_lines.append(line)
+                if line.endswith(";"):
+                    in_sql = False
+
+            if sql_lines:
+                query = "\n".join(sql_lines)
+
+        # Remove any backticks that might be at the start or end
+        query = query.strip("`")
+
+        # Then remove surrounding quotes (single or double) if they exist
+        query = query.strip()
+        if (query.startswith('"') and query.endswith('"')) or (query.startswith("'") and query.endswith("'")):
+            query = query[1:-1]
+
+        # Finally, clean up any remaining whitespace and ensure no backticks remain
+        query = query.strip()
+        # Remove any remaining backticks, but preserve them if they're part of a table/column name
+        # This regex will remove backticks that are not part of a valid identifier
+        return re.sub(r"`(?![a-zA-Z0-9_])|(?<![a-zA-Z0-9_])`", "", query)
+
+    def execute_sql(self) -> DataFrame:
+        try:
+            # First try to read the file
+            try:
+                service_account_path = Path(self.service_account_json_file)
+                with service_account_path.open() as f:
+                    credentials_json = json.load(f)
+                    project_id = credentials_json.get("project_id")
+                    if not project_id:
+                        msg = "No project_id found in service account credentials file."
+                        raise ValueError(msg)
+            except FileNotFoundError as e:
+                msg = f"Service account file not found: {e}"
+                raise ValueError(msg) from e
+            except json.JSONDecodeError as e:
+                msg = "Invalid JSON string for service account credentials"
+                raise ValueError(msg) from e
+
+            # Then try to load credentials
+            try:
+                credentials = Credentials.from_service_account_file(self.service_account_json_file)
+            except Exception as e:
+                msg = f"Error loading service account credentials: {e}"
+                raise ValueError(msg) from e
+
+        except ValueError:
+            raise
+        except Exception as e:
+            msg = f"Error executing BigQuery SQL query: {e}"
+            raise ValueError(msg) from e
+
+        try:
+            client = bigquery.Client(credentials=credentials, project=project_id)
+
+            # Check for empty or whitespace-only query before cleaning
+            if not str(self.query).strip():
+                msg = "No valid SQL query found in input text."
+                raise ValueError(msg)
+
+            # Always clean the query if it contains code block markers, quotes, or if clean_query is enabled
+            if "```" in str(self.query) or '"' in str(self.query) or "'" in str(self.query) or self.clean_query:
+                sql_query = self._clean_sql_query(str(self.query))
+            else:
+                sql_query = str(self.query).strip()  # At minimum, strip whitespace
+
+            query_job = client.query(sql_query)
+            results = query_job.result()
+            output_dict = [dict(row) for row in results]
+
+        except RefreshError as e:
+            msg = "Authentication error: Unable to refresh authentication token. Please try to reauthenticate."
+            raise ValueError(msg) from e
+        except Exception as e:
+            msg = f"Error executing BigQuery SQL query: {e}"
+            raise ValueError(msg) from e
+
+        return DataFrame(output_dict)

lfx_google/components/google/google_drive.py

@@ -0,0 +1,91 @@
+import json
+from json.decoder import JSONDecodeError
+
+from google.auth.exceptions import RefreshError
+from google.oauth2.credentials import Credentials
+from langchain_google_community import GoogleDriveLoader
+from lfx.custom.custom_component.component import Component
+from lfx.helpers.data import docs_to_data
+from lfx.inputs.inputs import MessageTextInput
+from lfx.io import SecretStrInput
+from lfx.schema.data import Data
+from lfx.template.field.base import Output
+
+
+class GoogleDriveComponent(Component):
+    display_name = "Google Drive Loader"
+    description = "Loads documents from Google Drive using provided credentials."
+    icon = "Google"
+    legacy: bool = True
+
+    inputs = [
+        SecretStrInput(
+            name="json_string",
+            display_name="JSON String of the Service Account Token",
+            info="JSON string containing OAuth 2.0 access token information for service account access",
+            required=True,
+        ),
+        MessageTextInput(
+            name="document_id", display_name="Document ID", info="Single Google Drive document ID", required=True
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Loaded Documents", name="docs", method="load_documents"),
+    ]
+
+    def load_documents(self) -> Data:
+        class CustomGoogleDriveLoader(GoogleDriveLoader):
+            creds: Credentials | None = None
+            """Credentials object to be passed directly."""
+
+            def _load_credentials(self):
+                """Load credentials from the provided creds attribute or fallback to the original method."""
+                if self.creds:
+                    return self.creds
+                msg = "No credentials provided."
+                raise ValueError(msg)
+
+            class Config:
+                arbitrary_types_allowed = True
+
+        json_string = self.json_string
+
+        document_ids = [self.document_id]
+        if len(document_ids) != 1:
+            msg = "Expected a single document ID"
+            raise ValueError(msg)
+
+        # TODO: Add validation to check if the document ID is valid
+
+        # Load the token information from the JSON string
+        try:
+            token_info = json.loads(json_string)
+        except JSONDecodeError as e:
+            msg = "Invalid JSON string"
+            raise ValueError(msg) from e
+
+        # Initialize the custom loader with the provided credentials and document IDs
+        loader = CustomGoogleDriveLoader(
+            creds=Credentials.from_authorized_user_info(token_info), document_ids=document_ids
+        )
+
+        # Load the documents
+        try:
+            docs = loader.load()
+        # catch google.auth.exceptions.RefreshError
+        except RefreshError as e:
+            msg = "Authentication error: Unable to refresh authentication token. Please try to reauthenticate."
+            raise ValueError(msg) from e
+        except Exception as e:
+            msg = f"Error loading documents: {e}"
+            raise ValueError(msg) from e
+
+        if len(docs) != 1:
+            msg = "Expected a single document to be loaded."
+            raise ValueError(msg)
+
+        data = docs_to_data(docs)
+        # Return the loaded documents
+        self.status = data
+        return Data(data={"text": data})

lfx_google/components/google/google_drive_search.py

@@ -0,0 +1,164 @@
+import json
+from json.decoder import JSONDecodeError
+
+from google.auth.exceptions import RefreshError
+from google.oauth2.credentials import Credentials
+from googleapiclient.discovery import build
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import DropdownInput, MessageTextInput
+from lfx.io import SecretStrInput
+from lfx.schema.data import Data
+from lfx.template.field.base import Output
+
+
+class GoogleDriveSearchComponent(Component):
+    display_name = "Google Drive Search"
+    description = "Searches Google Drive files using provided credentials and query parameters."
+    icon = "Google"
+    legacy: bool = True
+
+    inputs = [
+        SecretStrInput(
+            name="token_string",
+            display_name="Token String",
+            info="JSON string containing OAuth 2.0 access token information for service account access",
+            required=True,
+        ),
+        DropdownInput(
+            name="query_item",
+            display_name="Query Item",
+            options=[
+                "name",
+                "fullText",
+                "mimeType",
+                "modifiedTime",
+                "viewedByMeTime",
+                "trashed",
+                "starred",
+                "parents",
+                "owners",
+                "writers",
+                "readers",
+                "sharedWithMe",
+                "createdTime",
+                "properties",
+                "appProperties",
+                "visibility",
+                "shortcutDetails.targetId",
+            ],
+            info="The field to query.",
+            required=True,
+        ),
+        DropdownInput(
+            name="valid_operator",
+            display_name="Valid Operator",
+            options=["contains", "=", "!=", "<=", "<", ">", ">=", "in", "has"],
+            info="Operator to use in the query.",
+            required=True,
+        ),
+        MessageTextInput(
+            name="search_term",
+            display_name="Search Term",
+            info="The value to search for in the specified query item.",
+            required=True,
+        ),
+        MessageTextInput(
+            name="query_string",
+            display_name="Query String",
+            info="The query string used for searching. You can edit this manually.",
+            value="",  # This will be updated with the generated query string
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Document URLs", name="doc_urls", method="search_doc_urls"),
+        Output(display_name="Document IDs", name="doc_ids", method="search_doc_ids"),
+        Output(display_name="Document Titles", name="doc_titles", method="search_doc_titles"),
+        Output(display_name="JSON", name="Data", method="search_data"),
+    ]
+
+    def generate_query_string(self) -> str:
+        query_item = self.query_item
+        valid_operator = self.valid_operator
+        search_term = self.search_term
+
+        # Construct the query string
+        query = f"{query_item} {valid_operator} '{search_term}'"
+
+        # Update the editable query string input with the generated query
+        self.query_string = query
+
+        return query
+
+    def on_inputs_changed(self) -> None:
+        # Automatically regenerate the query string when inputs change
+        self.generate_query_string()
+
+    def generate_file_url(self, file_id: str, mime_type: str) -> str:
+        """Generates the appropriate Google Drive URL for a file based on its MIME type."""
+        return {
+            "application/vnd.google-apps.document": f"https://docs.google.com/document/d/{file_id}/edit",
+            "application/vnd.google-apps.spreadsheet": f"https://docs.google.com/spreadsheets/d/{file_id}/edit",
+            "application/vnd.google-apps.presentation": f"https://docs.google.com/presentation/d/{file_id}/edit",
+            "application/vnd.google-apps.drawing": f"https://docs.google.com/drawings/d/{file_id}/edit",
+            "application/pdf": f"https://drive.google.com/file/d/{file_id}/view?usp=drivesdk",
+        }.get(mime_type, f"https://drive.google.com/file/d/{file_id}/view?usp=drivesdk")
+
+    def search_files(self) -> dict:
+        # Load the token information from the JSON string
+        try:
+            token_info = json.loads(self.token_string)
+        except JSONDecodeError as e:
+            msg = "Invalid JSON string"
+            raise ValueError(msg) from e
+
+        # Use the query string from the input (which might have been edited by the user)
+        query = self.query_string or self.generate_query_string()
+
+        try:
+            creds = Credentials.from_authorized_user_info(token_info)
+            service = build("drive", "v3", credentials=creds)
+            results = (
+                service.files().list(q=query, pageSize=5, fields="nextPageToken, files(id, name, mimeType)").execute()
+            )
+        except RefreshError as e:
+            msg = "Authentication error: Unable to refresh authentication token. Please try to reauthenticate."
+            raise ValueError(msg) from e
+        except Exception as e:
+            msg = f"Error searching Google Drive: {e}"
+            raise ValueError(msg) from e
+
+        items = results.get("files", [])
+
+        doc_urls = []
+        doc_ids = []
+        doc_titles_urls = []
+        doc_titles = []
+
+        if items:
+            for item in items:
+                # Directly use the file ID, title, and MIME type to generate the URL
+                file_id = item["id"]
+                file_title = item["name"]
+                mime_type = item["mimeType"]
+                file_url = self.generate_file_url(file_id, mime_type)
+
+                # Store the URL, ID, and title+URL in their respective lists
+                doc_urls.append(file_url)
+                doc_ids.append(file_id)
+                doc_titles.append(file_title)
+                doc_titles_urls.append({"title": file_title, "url": file_url})
+
+        return {"doc_urls": doc_urls, "doc_ids": doc_ids, "doc_titles_urls": doc_titles_urls, "doc_titles": doc_titles}
+
+    def search_doc_ids(self) -> list[str]:
+        return self.search_files()["doc_ids"]
+
+    def search_doc_urls(self) -> list[str]:
+        return self.search_files()["doc_urls"]
+
+    def search_doc_titles(self) -> list[str]:
+        return self.search_files()["doc_titles"]
+
+    def search_data(self) -> Data:
+        return Data(data={"text": self.search_files()["doc_titles_urls"]})

lfx_google/components/google/google_generative_ai.py

@@ -0,0 +1,143 @@
+from typing import Any
+
+import requests
+from google import genai
+from lfx.base.models.google_generative_ai_constants import GOOGLE_GENERATIVE_AI_MODELS
+from lfx.base.models.google_generative_ai_model import ChatGoogleGenerativeAIFixed
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import BoolInput, DropdownInput, FloatInput, IntInput, SecretStrInput, SliderInput
+from lfx.log.logger import logger
+from lfx.schema.dotdict import dotdict
+from pydantic.v1 import SecretStr
+
+
+class GoogleGenerativeAIComponent(LCModelComponent):
+    display_name = "Google Generative AI"
+    description = "Generate text using Google Generative AI."
+    icon = "GoogleGenerativeAI"
+    name = "GoogleGenerativeAIModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        IntInput(
+            name="max_output_tokens", display_name="Max Output Tokens", info="The maximum number of tokens to generate."
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model",
+            info="The name of the model to use.",
+            options=GOOGLE_GENERATIVE_AI_MODELS,
+            value="gemini-2.5-flash",
+            refresh_button=True,
+            combobox=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="Google API Key",
+            info="The Google API Key to use for the Google Generative AI.",
+            required=True,
+            real_time_refresh=True,
+        ),
+        FloatInput(
+            name="top_p",
+            display_name="Top P",
+            info="The maximum cumulative probability of tokens to consider when sampling.",
+            advanced=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            info="Controls randomness. Lower values are more deterministic, higher values are more creative.",
+        ),
+        IntInput(
+            name="n",
+            display_name="N",
+            info="Number of chat completions to generate for each prompt. "
+            "Note that the API may not return the full n completions if duplicates are generated.",
+            advanced=True,
+        ),
+        IntInput(
+            name="top_k",
+            display_name="Top K",
+            info="Decode using top-k sampling: consider the set of top_k most probable tokens. Must be positive.",
+            advanced=True,
+        ),
+        BoolInput(
+            name="tool_model_enabled",
+            display_name="Tool Model Enabled",
+            info="Whether to use the tool model.",
+            value=False,
+        ),
+    ]
+
+    def build_model(self) -> LanguageModel:  # type: ignore[type-var]
+        google_api_key = self.api_key
+        model = self.model_name
+        max_output_tokens = self.max_output_tokens
+        temperature = self.temperature
+        top_k = self.top_k
+        top_p = self.top_p
+        n = self.n
+
+        # Use modified ChatGoogleGenerativeAIFixed class for multiple function support
+        # TODO: Potentially remove when fixed upstream
+        return ChatGoogleGenerativeAIFixed(
+            model=model,
+            max_output_tokens=max_output_tokens or None,
+            temperature=temperature,
+            top_k=top_k or None,
+            top_p=top_p or None,
+            n=n or 1,
+            google_api_key=SecretStr(google_api_key).get_secret_value(),
+        )
+
+    def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
+        try:
+            with genai.Client(api_key=self.api_key) as client:
+                model_ids = [
+                    model.name.removeprefix("models/")
+                    for model in client.models.list()
+                    if model.name and "generateContent" in (model.supported_actions or [])
+                ]
+            model_ids.sort(reverse=True)
+        except (genai.errors.APIError, ValueError) as e:
+            logger.exception(f"Error getting model names: {e}")
+            model_ids = GOOGLE_GENERATIVE_AI_MODELS
+        if tool_model_enabled:
+            try:
+                from langchain_google_genai.chat_models import ChatGoogleGenerativeAI
+            except ImportError as e:
+                msg = "langchain_google_genai is not installed."
+                raise ImportError(msg) from e
+            model_ids = [
+                model
+                for model in model_ids
+                if self.supports_tool_calling(ChatGoogleGenerativeAI(model=model, google_api_key=self.api_key))
+            ]
+        return model_ids
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None):
+        if field_name in {"base_url", "model_name", "tool_model_enabled", "api_key"} and field_value:
+            try:
+                if len(self.api_key) == 0:
+                    ids = GOOGLE_GENERATIVE_AI_MODELS
+                else:
+                    try:
+                        ids = self.get_models(tool_model_enabled=self.tool_model_enabled)
+                    except (ImportError, ValueError, requests.exceptions.RequestException) as e:
+                        logger.exception(f"Error getting model names: {e}")
+                        ids = GOOGLE_GENERATIVE_AI_MODELS
+                build_config.setdefault("model_name", {})
+                build_config["model_name"]["options"] = ids
+                if ids:
+                    build_config["model_name"].setdefault("value", ids[0])
+                else:
+                    build_config["model_name"].pop("value", None)
+            except Exception as e:
+                msg = f"Error getting model names: {e}"
+                raise ValueError(msg) from e
+        return build_config

lfx_google/components/google/google_generative_ai_embeddings.py

@@ -0,0 +1,34 @@
+from langchain_core.embeddings import Embeddings
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageTextInput, Output, SecretStrInput
+
+
+class GoogleGenerativeAIEmbeddingsComponent(Component):
+    display_name = "Google Generative AI Embeddings"
+    description = (
+        "Connect to Google's generative AI embeddings service using the GoogleGenerativeAIEmbeddings class, "
+        "found in the langchain-google-genai package."
+    )
+    documentation: str = "https://python.langchain.com/v0.2/docs/integrations/text_embedding/google_generative_ai/"
+    icon = "GoogleGenerativeAI"
+    name = "Google Generative AI Embeddings"
+
+    inputs = [
+        SecretStrInput(name="api_key", display_name="Google Generative AI API Key", required=True),
+        MessageTextInput(name="model_name", display_name="Model Name", value="models/text-embedding-004"),
+    ]
+
+    outputs = [
+        Output(display_name="Embeddings", name="embeddings", method="build_embeddings"),
+    ]
+
+    def build_embeddings(self) -> Embeddings:
+        if not self.api_key:
+            msg = "API Key is required"
+            raise ValueError(msg)
+
+        return GoogleGenerativeAIEmbeddings(
+            model=self.model_name,
+            google_api_key=self.api_key,
+        )

lfx_google/components/google/google_oauth_token.py

@@ -0,0 +1,73 @@
+import json
+import re
+
+from google_auth_oauthlib.flow import InstalledAppFlow
+from lfx.custom.custom_component.component import Component
+from lfx.io import FileInput, MultilineInput, Output
+from lfx.schema.data import Data
+
+_SCOPE = (
+    r"(?:https://www\.googleapis\.com/auth/[\w.\-]+"
+    r"|mail\.google\.com/"
+    r"|www\.google\.com/calendar/feeds"
+    r"|www\.google\.com/m8/feeds)"
+)
+_SCOPE_LIST_PATTERN = re.compile(rf"{_SCOPE}(?:,\s*{_SCOPE})*")
+_OAUTH_CALLBACK_TIMEOUT_SECONDS = 300
+
+
+class GoogleOAuthToken(Component):
+    display_name = "Google OAuth Token"
+    description = "Generates a JSON string with your Google OAuth token."
+    documentation: str = "https://developers.google.com/identity/protocols/oauth2/web-server?hl=pt-br#python_1"
+    icon = "Google"
+    name = "GoogleOAuthToken"
+    legacy: bool = True
+    inputs = [
+        MultilineInput(
+            name="scopes",
+            display_name="Scopes",
+            info="Input scopes for your application.",
+            required=True,
+        ),
+        FileInput(
+            name="oauth_credentials",
+            display_name="Credentials File",
+            info="Input OAuth Credentials file (e.g. credentials.json).",
+            file_types=["json"],
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Output", name="output", method="build_output"),
+    ]
+
+    def validate_scopes(self, scopes: str) -> None:
+        if _SCOPE_LIST_PATTERN.fullmatch(scopes) is None:
+            error_message = "Invalid scope format."
+            raise ValueError(error_message)
+
+    def build_output(self) -> Data:
+        self.validate_scopes(self.scopes)
+
+        user_scopes = [scope.strip() for scope in self.scopes.split(",")]
+        if self.scopes:
+            scopes = user_scopes
+        else:
+            error_message = "Incorrect scope, check the scopes field."
+            raise ValueError(error_message)
+
+        if not self.oauth_credentials:
+            error_message = "OAuth 2.0 Credentials file not provided."
+            raise ValueError(error_message)
+
+        try:
+            flow = InstalledAppFlow.from_client_secrets_file(self.oauth_credentials, scopes)
+            creds = flow.run_local_server(port=0, timeout_seconds=_OAUTH_CALLBACK_TIMEOUT_SECONDS)
+            creds_json = json.loads(creds.to_json())
+        except Exception as e:
+            msg = f"OAuth authorization failed: {e}"
+            raise ValueError(msg) from e
+
+        return Data(data=creds_json)

lfx_google/components/google/google_search_api_core.py

@@ -0,0 +1,67 @@
+from langchain_google_community import GoogleSearchAPIWrapper
+from lfx.custom.custom_component.component import Component
+from lfx.io import IntInput, MultilineInput, Output, SecretStrInput
+from lfx.schema.dataframe import DataFrame
+
+
+class GoogleSearchAPICore(Component):
+    display_name = "Google Search API"
+    description = "Call Google Search API and return results as a DataFrame."
+    icon = "Google"
+
+    inputs = [
+        SecretStrInput(
+            name="google_api_key",
+            display_name="Google API Key",
+            required=True,
+        ),
+        SecretStrInput(
+            name="google_cse_id",
+            display_name="Google CSE ID",
+            required=True,
+        ),
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+            tool_mode=True,
+        ),
+        IntInput(
+            name="k",
+            display_name="Number of results",
+            value=4,
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Results",
+            name="results",
+            type_=DataFrame,
+            method="search_google",
+        ),
+    ]
+
+    def search_google(self) -> DataFrame:
+        """Search Google using the provided query."""
+        if not self.google_api_key:
+            return DataFrame([{"error": "Invalid Google API Key"}])
+
+        if not self.google_cse_id:
+            return DataFrame([{"error": "Invalid Google CSE ID"}])
+
+        try:
+            wrapper = GoogleSearchAPIWrapper(
+                google_api_key=self.google_api_key, google_cse_id=self.google_cse_id, k=self.k
+            )
+            results = wrapper.results(query=self.input_value, num_results=self.k)
+            return DataFrame(results)
+        except (ValueError, KeyError) as e:
+            return DataFrame([{"error": f"Invalid configuration: {e!s}"}])
+        except ConnectionError as e:
+            return DataFrame([{"error": f"Connection error: {e!s}"}])
+        except RuntimeError as e:
+            return DataFrame([{"error": f"Error occurred while searching: {e!s}"}])
+
+    def build(self):
+        return self.search_google

lfx_google/components/google/google_serper_api_core.py

@@ -0,0 +1,73 @@
+from langchain_community.utilities.google_serper import GoogleSerperAPIWrapper
+from lfx.custom.custom_component.component import Component
+from lfx.io import IntInput, MultilineInput, Output, SecretStrInput
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.message import Message
+
+
+class GoogleSerperAPICore(Component):
+    display_name = "Google Serper API"
+    description = "Call the Serper.dev Google Search API."
+    icon = "Serper"
+
+    inputs = [
+        SecretStrInput(
+            name="serper_api_key",
+            display_name="Serper API Key",
+            required=True,
+        ),
+        MultilineInput(
+            name="input_value",
+            display_name="Input",
+            tool_mode=True,
+        ),
+        IntInput(
+            name="k",
+            display_name="Number of results",
+            value=4,
+            required=True,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Results",
+            name="results",
+            type_=DataFrame,
+            method="search_serper",
+        ),
+    ]
+
+    def search_serper(self) -> DataFrame:
+        try:
+            wrapper = self._build_wrapper()
+            results = wrapper.results(query=self.input_value)
+            list_results = results.get("organic", [])
+
+            # Convert results to DataFrame using list comprehension
+            df_data = [
+                {
+                    "title": result.get("title", ""),
+                    "link": result.get("link", ""),
+                    "snippet": result.get("snippet", ""),
+                }
+                for result in list_results
+            ]
+
+            return DataFrame(df_data)
+        except (ValueError, KeyError, ConnectionError) as e:
+            error_message = f"Error occurred while searching: {e!s}"
+            self.status = error_message
+            # Return DataFrame with error as a list of dictionaries
+            return DataFrame([{"error": error_message}])
+
+    def text_search_serper(self) -> Message:
+        search_results = self.search_serper()
+        text_result = search_results.to_string(index=False) if not search_results.empty else "No results found."
+        return Message(text=text_result)
+
+    def _build_wrapper(self):
+        return GoogleSerperAPIWrapper(serper_api_key=self.serper_api_key, k=self.k)
+
+    def build(self):
+        return self.search_serper

lfx_google/extension.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://schemas.langflow.org/extension/v1.json",
+  "id": "lfx-google",
+  "version": "0.1.0",
+  "name": "Google",
+  "description": "Google and Gemini components as a standalone Langflow Extension Bundle.",
+  "lfx": {
+    "compat": ["1"]
+  },
+  "bundles": [
+    {
+      "name": "google",
+      "path": "components/google"
+    }
+  ]
+}

lfx_google-0.1.0.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: lfx-google
+Version: 0.1.0
+Summary: Google and Gemini components as a standalone Langflow Extension Bundle.
+Project-URL: Homepage, https://github.com/langflow-ai/langflow
+Project-URL: Documentation, https://docs.langflow.org/extensions
+Project-URL: Repository, https://github.com/langflow-ai/langflow
+Author-email: Langflow <contact@langflow.org>
+License: MIT
+Keywords: bundle,extension,gemini,google,langflow,lfx
+Requires-Python: <3.15,>=3.10
+Requires-Dist: google-api-python-client~=2.161
+Requires-Dist: google-auth-oauthlib<2.0.0,>=1.2.0
+Requires-Dist: google-auth<3.0.0,>=2.38.0
+Requires-Dist: google-cloud-bigquery<4.0.0,>=3.35
+Requires-Dist: google-genai<2.0.0,>=1.75.0
+Requires-Dist: langchain-community<1.0.0,>=0.4.1
+Requires-Dist: langchain-core<2.0.0,>=1.2.28
+Requires-Dist: langchain-google-community~=3.0.2
+Requires-Dist: langchain-google-genai~=4.1.2
+Requires-Dist: lfx<2.0.0,>=1.12.0.dev0
+Requires-Dist: requests>=2.32.0
+Description-Content-Type: text/markdown
+
+# lfx-google
+
+Google and Gemini components as a standalone Langflow Extension Bundle.
+
+## Install
+
+```bash
+pip install lfx-google
+```
+
+`pip install langflow` includes this bundle because Google Generative AI is a
+supported model provider. The bundle is registered automatically through the
+`langflow.extensions` entry point and appears under the `google` group with
+canonical component IDs such as
+`ext:google:GoogleGenerativeAIComponent@official`.
+
+## Develop
+
+```bash
+uv sync
+uv run pytest src/bundles/google/tests -q
+uv run lfx extension validate src/bundles/google/src/lfx_google
+```
+
+The bundle graduated from the manifest-less `lfx-bundles[google]` provider in
+Langflow 1.12. Its bundle and class names are unchanged, so existing saved
+flows retain their canonical IDs.

lfx_google-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+lfx_google/__init__.py,sha256=otSehMGsu4GYVLKuf493KxZygS3S50AkRL9MhbxCXl0,654
+lfx_google/extension.json,sha256=X2gy2jjV9cAyO_21K1LDKX9Ape-UPpVFsn6u3oTAp9M,348
+lfx_google/components/__init__.py,sha256=jGP4Ar-Vtdchu8QaxhwKCTOEp9J_jWkfCxIBaas2VNM,48
+lfx_google/components/google/__init__.py,sha256=W37__Q4kjIEeQ11_pRaIFEaXBABxL6E4JcEUNuEeoo4,811
+lfx_google/components/google/gmail.py,sha256=-mqUSJzqgPEnqvN44ApHhxTEVHD8aCr2-IZH_qvAfog,8162
+lfx_google/components/google/google_bq_sql_executor.py,sha256=DH0aqkMPAb9RFbFPfQR-1xOg4CWvNDfWs10fth-5iOo,6006
+lfx_google/components/google/google_drive.py,sha256=I7wJEuO967kkenqi0td3YvP58C6j4k7ZsydCmCESAFc,3255
+lfx_google/components/google/google_drive_search.py,sha256=4-FbgjFSwpKFWRBpYbpb9LIwAmVLeZ_2D5N_pLtktmY,6421
+lfx_google/components/google/google_generative_ai.py,sha256=8oMJvtUWKZ-ttgagD1rZEQOws9cZHUMqDK996rTO0yo,5875
+lfx_google/components/google/google_generative_ai_embeddings.py,sha256=YviG05Zqq9JTv95tBUpFJUkkjnFAvFnvKi0rvFjc9M0,1351
+lfx_google/components/google/google_oauth_token.py,sha256=iNQyPmqgHfdxPtX3d8HgV4uPvAUspYOhdoIB4WINxOQ,2503
+lfx_google/components/google/google_search_api_core.py,sha256=DiHhK98fwSTg6Ai_W1hTxBuRWP8E34ioWK7afCf1bZg,2156
+lfx_google/components/google/google_serper_api_core.py,sha256=arq2nuTCZt_KJXnyLmzCLjJ8I8aOdtm4sULHoa3ODoc,2379
+lfx_google-0.1.0.dist-info/METADATA,sha256=DsiQNtyy8j6BVs9Ua8BhPmssF8e5JG5en3mpXC02W5k,1779
+lfx_google-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+lfx_google-0.1.0.dist-info/entry_points.txt,sha256=IOiUskTWYt3L60LBArI5MT7jYvh8Y3k2-KoI65tdXPs,46
+lfx_google-0.1.0.dist-info/RECORD,,

lfx_google-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

lfx_google-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[langflow.extensions]
+lfx-google = lfx_google