alita-sdk 0.3.270__py3-none-any.whl → 0.3.272__py3-none-any.whl

alita_sdk/configurations/__init__.py

@@ -41,8 +41,18 @@ _safe_import_configuration('bigquery', 'bigquery', 'BigQueryConfiguration')
 _safe_import_configuration('xray', 'xray', 'XrayConfiguration')
 _safe_import_configuration('zephyr', 'zephyr', 'ZephyrConfiguration')
 _safe_import_configuration('zephyr_enterprise', 'zephyr_enterprise', 'ZephyrEnterpriseConfiguration')
+_safe_import_configuration('zephyr_essential', 'zephyr_essential', 'ZephyrEssentialConfiguration')
 _safe_import_configuration('figma', 'figma', 'FigmaConfiguration')
 _safe_import_configuration('rally', 'rally', 'RallyConfiguration')
+_safe_import_configuration('sonar', 'sonar', 'SonarConfiguration')
+_safe_import_configuration('sql', 'sql', 'SqlConfiguration')
+_safe_import_configuration('google_places', 'google_places', 'GooglePlacesConfiguration')
+_safe_import_configuration('salesforce', 'salesforce', 'SalesforceConfiguration')
+_safe_import_configuration('browser', 'browser', 'BrowserConfiguration')
+_safe_import_configuration('sharepoint', 'sharepoint', 'SharepointConfiguration')
+_safe_import_configuration('carrier', 'carrier', 'CarrierConfiguration')
+_safe_import_configuration('report_portal', 'report_portal', 'ReportPortalConfiguration')
+_safe_import_configuration('testio', 'testio', 'TestIOConfiguration')
 
 # Log import summary
 available_count = len(AVAILABLE_CONFIGURATIONS)

alita_sdk/configurations/ado.py

@@ -10,7 +10,8 @@ class AdoConfiguration(BaseModel):
                 "label": "Ado",
                 "icon_url": None,
                 "section": "credentials",
-                "type": "ado"
+                "type": "ado",
+                "categories": ["project management"],
             }
         }
     )
@@ -26,7 +27,8 @@ class AdoReposConfiguration(BaseModel):
                 "label": "ADO repos",
                 "icon_url": "ado-repos-icon.svg",
                 "section": "credentials",
-                "type": "ado_repos"
+                "type": "ado_repos",
+                "categories": ["code repositories"],
             }
         }
     )

alita_sdk/configurations/azure_search.py

@@ -12,7 +12,7 @@ class AzureSearchConfiguration(BaseModel):
                 "hidden": True,
                 "section": "credentials",
                 "type": "azure_search",
-                "categories": ["search"],
+                "categories": ["other"],
                 "extra_categories": ["azure", "cognitive search", "vector database", "knowledge base"],
             }
         }

alita_sdk/configurations/bigquery.py

@@ -12,7 +12,7 @@ class BigQueryConfiguration(BaseModel):
                 "hidden": True,
                 "section": "credentials",
                 "type": "bigquery",
-                "categories": ["database"],
+                "categories": ["other"],
                 "extra_categories": ["google", "gcp", "data warehouse", "analytics"],
             }
         }

alita_sdk/configurations/browser.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class BrowserConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Browser",
+                "icon_url": "browser.svg",
+                "section": "credentials",
+                "type": "browser",
+                "categories": ["testing"],
+                "extra_categories": ["browser", "google", "search", "web"],
+            }
+        }
+    )
+    google_cse_id: str = Field(description="Google CSE id", default=None)
+    google_api_key: SecretStr = Field(description="Google API key", default=None, json_schema_extra={'secret': True})

alita_sdk/configurations/carrier.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class CarrierConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Carrier",
+                "icon_url": "carrier.svg",
+                "section": "credentials",
+                "type": "carrier",
+                "categories": ["testing"],
+                "extra_categories": ["carrier", "security", "testing", "vulnerability"],
+            }
+        }
+    )
+    organization: str = Field(description="Carrier Organization")
+    url: str = Field(description="Carrier URL")
+    private_token: SecretStr = Field(description="Carrier Private Token")

alita_sdk/configurations/delta_lake.py

@@ -12,7 +12,7 @@ class DeltaLakeConfiguration(BaseModel):
                 "hidden": True,
                 "section": "credentials",
                 "type": "delta_lake",
-                "categories": ["database"],
+                "categories": ["other"],
                 "extra_categories": ["aws", "data lake", "analytics", "storage"],
             }
         }

alita_sdk/configurations/google_places.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class GooglePlacesConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Google Places",
+                "icon_url": "google.svg",
+                "section": "credentials",
+                "type": "google_places",
+                "categories": ["other"],
+                "extra_categories": ["google", "places", "maps", "location", "geocoding"],
+            }
+        }
+    )
+    api_key: SecretStr = Field(description="Google Places API Key")

alita_sdk/configurations/postman.py

@@ -22,7 +22,7 @@ class PostmanConfiguration(BaseModel):
                 },
                 "section": "credentials",
                 "type": "postman",
-                "categories": ["api testing"],
+                "categories": ["other"],
                 "extra_categories": ["postman", "api", "testing", "collection"],
             }
         }

alita_sdk/configurations/qtest.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from pydantic import BaseModel, ConfigDict, Field, SecretStr
 
 
@@ -17,5 +15,5 @@ class QtestConfiguration(BaseModel):
         }
     )
     base_url: str = Field(description="QTest base url")
-    qtest_api_token: Optional[SecretStr] = Field(description="QTest API token", default=None)
+    qtest_api_token: SecretStr = Field(description="QTest API token", default=None)
 

alita_sdk/configurations/report_portal.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class ReportPortalConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Report Portal",
+                "icon_url": "report_portal.svg",
+                "section": "credentials",
+                "type": "report_portal",
+                "categories": ["testing"],
+                "extra_categories": ["report portal", "testing", "automation", "reports"],
+            }
+        }
+    )
+    project: str = Field(description="Report Portal Project Name")
+    endpoint: str = Field(description="Report Portal Endpoint URL")
+    api_key: SecretStr = Field(description="Report Portal API Key")

alita_sdk/configurations/salesforce.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class SalesforceConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Salesforce",
+                "icon_url": "salesforce.svg",
+                "section": "credentials",
+                "type": "salesforce",
+                "categories": ["other"],
+                "extra_categories": ["salesforce", "crm", "sales", "customer"],
+            }
+        }
+    )
+    client_id: str = Field(description="Salesforce Client ID")
+    client_secret: SecretStr = Field(description="Salesforce Client Secret")
+    base_url: str = Field(description="Salesforce Base URL")

alita_sdk/configurations/service_now.py

@@ -9,20 +9,9 @@ class ServiceNowConfiguration(BaseModel):
             "metadata": {
                 "label": "ServiceNow",
                 "icon_url": "servicenow.svg",
-                "sections": {
-                    "auth": {
-                        "required": True,
-                        "subsections": [
-                            {
-                                "name": "Username & Password",
-                                "fields": ["username", "password"]
-                            }
-                        ]
-                    },
-                },
                 "section": "credentials",
                 "type": "service_now",
-                "categories": ["service management"],
+                "categories": ["other"],
                 "extra_categories": ["servicenow", "itsm", "service management", "incident"],
             }
         }

alita_sdk/configurations/sharepoint.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class SharepointConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "SharePoint",
+                "icon_url": "sharepoint.svg",
+                "section": "credentials",
+                "type": "sharepoint",
+                "categories": ["office"],
+                "extra_categories": ["sharepoint", "microsoft", "documents", "collaboration"],
+            }
+        }
+    )
+    client_id: str = Field(description="SharePoint Client ID")
+    client_secret: SecretStr = Field(description="SharePoint Client Secret")
+    site_url: str = Field(description="SharePoint Site URL")

alita_sdk/configurations/sonar.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class SonarConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Sonar",
+                "icon_url": "sonar-icon.svg",
+                "section": "credentials",
+                "type": "sonar",
+                "categories": ["development"],
+                "extra_categories": ["code quality", "code security", "code coverage", "quality", "sonarqube"],
+            }
+        }
+    )
+    url: str = Field(description="SonarQube Server URL")
+    sonar_token: SecretStr = Field(description="SonarQube user token for authentication")

alita_sdk/configurations/sql.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class SqlConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "SQL Database",
+                "icon_url": "sql.svg",
+                "section": "credentials",
+                "type": "sql",
+                "categories": ["development"],
+                "extra_categories": ["sql", "database", "data", "query"],
+            }
+        }
+    )
+    host: str = Field(description="Database host")
+    port: int = Field(description="Database port")
+    username: str = Field(description="Database username")
+    password: SecretStr = Field(description="Database password", json_schema_extra={'secret': True})

alita_sdk/configurations/testio.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class TestIOConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "TestIO",
+                "icon_url": "testio.svg",
+                "section": "credentials",
+                "type": "testio",
+                "categories": ["testing"],
+                "extra_categories": ["testio", "testing", "crowd testing", "qa"],
+            }
+        }
+    )
+    endpoint: str = Field(description="TestIO endpoint")
+    api_key: SecretStr = Field(description="TestIO API Key")

alita_sdk/configurations/zephyr_essential.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+
+class ZephyrEssentialConfiguration(BaseModel):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "metadata": {
+                "label": "Zephyr Essential",
+                "icon_url": "zephyr.svg",
+                "section": "credentials",
+                "type": "zephyr-essential",
+                "categories": ["test management"],
+                "extra_categories": ["zephyr", "test automation", "test case management", "test planning"],
+            }
+        }
+    )
+    base_url: str = Field(description="Zephyr Essential Base URL", default=None)
+    token: SecretStr = Field(description="Zephyr Essential API Token")

alita_sdk/runtime/langchain/document_loaders/AlitaImageLoader.py

@@ -151,5 +151,5 @@ class AlitaImageLoader(BaseLoader):
         """Load text from image using OCR or LLM if llm is provided, supports SVG."""
         text_content = self.get_content()
 
-        metadata = {"source": str(self.file_path)}  # Ensure source is always a string for metadata
+        metadata = {"source": str(self.file_path if hasattr(self, 'file_path') else self.file_name)}  # Ensure source is always a string for metadata
         return [Document(page_content=text_content, metadata=metadata)]

alita_sdk/runtime/langchain/document_loaders/AlitaPDFLoader.py

@@ -1,5 +1,7 @@
 import pymupdf
 from langchain_community.document_loaders import PyPDFLoader
+
+from .ImageParser import ImageParser
 from .utils import perform_llm_prediction_for_image_bytes, create_temp_file
 from langchain_core.tools import ToolException
 
@@ -54,10 +56,21 @@ class AlitaPDFLoader:
 
     def load(self):
         if not hasattr(self, 'file_path'):
-            self.file_path = create_temp_file(self.file_content)
+            import tempfile
+
+            with tempfile.NamedTemporaryFile(mode='w+b', delete=True, suffix=".pdf") as temp_file:
+                temp_file.write(self.file_content)
+                temp_file.flush()
+                self.file_path = temp_file.name
+                return self._load_docs()
+        else:
+            return self._load_docs()
+
+    def _load_docs(self):
         return PyPDFLoader(file_path=self.file_path,
-                           password=self.password,
-                           headers=self.headers,
-                           extract_images=self.extract_images,
-                           extraction_mode=self.extraction_mode,
-                           extraction_kwargs=self.extraction_kwargs).load()
+                        password=self.password,
+                        headers=self.headers,
+                        extract_images=self.extract_images,
+                        extraction_mode=self.extraction_mode,
+                        images_parser=ImageParser(llm=self.llm, prompt=self.prompt),
+                        extraction_kwargs=self.extraction_kwargs).load()

alita_sdk/runtime/langchain/document_loaders/ImageParser.py

@@ -0,0 +1,17 @@
+from langchain_community.document_loaders.parsers.images import BaseImageBlobParser
+
+from alita_sdk.runtime.langchain.document_loaders.AlitaImageLoader import AlitaImageLoader
+
+class ImageParser(BaseImageBlobParser):
+
+    def __init__(self, **kwargs):
+        self.llm = kwargs.get('llm')
+        self.prompt = kwargs.get('prompt')
+
+    def _analyze_image(self, img) -> str:
+        from io import BytesIO
+
+        byte_stream = BytesIO()
+        img.save(byte_stream, format='PNG')
+        image_bytes = byte_stream.getvalue()
+        return AlitaImageLoader(file_content=image_bytes, file_name="image.png", prompt=self.prompt, llm=self.llm).get_content()

alita_sdk/runtime/tools/vectorstore.py

@@ -212,10 +212,27 @@ class VectorStoreWrapper(BaseToolApiWrapper):
         """Get all indexed document IDs from vectorstore"""
         return self.vector_adapter.get_indexed_ids(self, collection_suffix)
 
-    def list_collections(self) -> List[str]:
-        """List all collections in the vectorstore."""
-
-        return self.vector_adapter.list_collections(self)
+    def list_collections(self) -> Any:
+        """List all collections in the vectorstore.
+        Returns a list of collection names, or if no collections exist,
+        returns a dict with an empty list and a message."""
+        raw = self.vector_adapter.list_collections(self)
+        # Normalize raw result to a list of names
+        if not raw:
+            # No collections found
+            return {"collections": [], "message": "No indexed collections"}
+        if isinstance(raw, str):
+            # e.g., Chroma adapter returns comma-separated string
+            cols = [c for c in raw.split(',') if c]
+        else:
+            try:
+                cols = list(raw)
+            except Exception:
+                # Unexpected type, return raw directly
+                return raw
+        if not cols:
+            return {"collections": [], "message": "No indexed collections"}
+        return cols
 
     def _clean_collection(self, collection_suffix: str = ''):
         """
@@ -765,4 +782,3 @@ class VectorStoreWrapper(BaseToolApiWrapper):
                 "args_schema": StepBackSearchDocumentsModel
             }
         ]
-

alita_sdk/runtime/tools/vectorstore_base.py

@@ -192,7 +192,10 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
     def list_collections(self) -> List[str]:
         """List all collections in the vectorstore."""
 
-        return self.vector_adapter.list_collections(self)
+        collections = self.vector_adapter.list_collections(self)
+        if not collections:
+            return "No indexed collections"
+        return collections
 
     def _clean_collection(self, collection_suffix: str = ''):
         """

alita_sdk/tools/aws/delta_lake/__init__.py

@@ -3,7 +3,7 @@ from functools import lru_cache
 from typing import List, Optional, Type
 
 from langchain_core.tools import BaseTool, BaseToolkit
-from pydantic import BaseModel, Field, SecretStr, computed_field, field_validator
+from pydantic import BaseModel, Field, computed_field, field_validator
 
 from alita_sdk.configurations.delta_lake import DeltaLakeConfiguration
 from ...utils import TOOLKIT_SPLITTER, clean_string, get_max_toolkit_length
@@ -54,7 +54,7 @@ class DeltaLakeToolkitConfig(BaseModel):
             }
         }
 
-    delta_lake_configuration: Optional[DeltaLakeConfiguration] = Field(description="Delta Lake Configuration", json_schema_extra={"configuration_types": ["delta_lake"]})
+    delta_lake_configuration: DeltaLakeConfiguration = Field(description="Delta Lake Configuration", json_schema_extra={"configuration_types": ["delta_lake"]})
     selected_tools: List[str] = Field(default=[], description="Selected tools", json_schema_extra={"args_schemas": get_available_tools()})
 
     @field_validator("selected_tools", mode="before", check_fields=False)

alita_sdk/tools/azure_ai/search/__init__.py

@@ -39,7 +39,7 @@ class AzureSearchToolkit(BaseToolkit):
             name,
             index_name=(str, Field(description="Azure Search index name")),
             azure_search_configuration=(
-                Optional[AzureSearchConfiguration],
+                AzureSearchConfiguration,
                 Field(description="Azure Search Configuration", json_schema_extra={'configuration_types': ['azure_search']})
             ),
             api_version=(Optional[str], Field(description="API version", default=None)),

alita_sdk/tools/bitbucket/__init__.py

@@ -6,6 +6,8 @@ from .api_wrapper import BitbucketAPIWrapper
 from langchain_core.tools import BaseToolkit
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel, Field, ConfigDict, create_model
+
+from ..base.tool import BaseAction
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
 from ...configurations.bitbucket import BitbucketConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
@@ -49,7 +51,7 @@ class AlitaBitbucketToolkit(BaseToolkit):
             repository=(str, Field(description="Repository", json_schema_extra={'max_toolkit_length': AlitaBitbucketToolkit.toolkit_max_length, 'configuration': True})),
             branch=(str, Field(description="Main branch", default="main")),
             cloud=(Optional[bool], Field(description="Hosting Option", default=None)),
-            bitbucket_configuration=(Optional[BitbucketConfiguration], Field(description="Bitbucket Configuration", json_schema_extra={'configuration_types': ['bitbucket']})),
+            bitbucket_configuration=(BitbucketConfiguration, Field(description="Bitbucket Configuration", json_schema_extra={'configuration_types': ['bitbucket']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None, description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
             embedding_model=(Optional[str], Field(default=None, description="Embedding configuration.", json_schema_extra={'configuration_model': 'embedding'})),
@@ -102,9 +104,12 @@ class AlitaBitbucketToolkit(BaseToolkit):
             if selected_tools:
                 if tool['name'] not in selected_tools:
                     continue
-            initiated_tool = tool['tool'](api_wrapper=bitbucket_api_wrapper)
-            initiated_tool.name = prefix + tool['name']
-            tools.append(initiated_tool)
+            tools.append(BaseAction(
+                api_wrapper=bitbucket_api_wrapper,
+                name=prefix + tool["name"],
+                description=tool["description"] + f"\nrepo: {bitbucket_api_wrapper.repository}",
+                args_schema=tool["args_schema"]
+            ))
         return cls(tools=tools)
 
     def get_tools(self):

alita_sdk/tools/bitbucket/api_wrapper.py

@@ -194,7 +194,7 @@ class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
             if limit is not None:
                 branches = branches[:limit]
 
-            return branches
+            return "Found branches: " + ", ".join(branches)
         except Exception as e:
             return f"Failed to list branches: {str(e)}"
 

alita_sdk/tools/bitbucket/cloud_api_wrapper.py

@@ -35,7 +35,7 @@ def normalize_response(response) -> Dict[str, Any]:
 class BitbucketApiAbstract(ABC):
 
     @abstractmethod
-    def list_branches(self) -> str:
+    def list_branches(self) -> List[str]:
         pass
 
     @abstractmethod
@@ -86,9 +86,9 @@ class BitbucketServerApi(BitbucketApiAbstract):
         self.password = password
         self.api_client = Bitbucket(url=url, username=username, password=password)
 
-    def list_branches(self) -> str:
+    def list_branches(self) -> List[str]:
         branches = self.api_client.get_branches(project_key=self.project, repository_slug=self.repository)
-        return json.dumps([branch['displayId'] for branch in branches])
+        return [branch['displayId'] for branch in branches]
 
     def create_branch(self, branch_name: str, branch_from: str) -> Response:
         return self.api_client.create_branch(
@@ -257,10 +257,10 @@ class BitbucketCloudApi(BitbucketApiAbstract):
         except Exception as e:
             raise ToolException(f"Unable to connect to the repository '{self.repository_name}' due to error:\n{str(e)}")
 
-    def list_branches(self) -> str:
+    def list_branches(self) -> List[str]:
         branches = self.repository.branches.each()
         branch_names = [branch.name for branch in branches]
-        return ', '.join(branch_names)
+        return branch_names
 
     def _get_branch(self, branch_name: str) -> Response:
         return self.repository.branches.get(branch_name)

alita_sdk/tools/browser/__init__.py

@@ -1,7 +1,7 @@
 from typing import List, Optional, Literal
 from langchain_core.tools import BaseTool, BaseToolkit
 
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr, model_validator
+from pydantic import create_model, BaseModel, ConfigDict, Field, model_validator
 
 from langchain_community.utilities.google_search import GoogleSearchAPIWrapper
 from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
@@ -9,6 +9,7 @@ from .google_search_rag import GoogleSearchResults
 from .crawler import SingleURLCrawler, MultiURLCrawler, GetHTMLContent, GetPDFContent
 from .wiki import WikipediaQueryRun
 from ..utils import get_max_toolkit_length, clean_string, TOOLKIT_SPLITTER
+from ...configurations.browser import BrowserConfiguration
 from logging import getLogger
 
 logger = getLogger(__name__)
@@ -19,8 +20,7 @@ name = "browser"
 def get_tools(tool):
     return BrowserToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        google_api_key=tool['settings'].get('google_api_key'),
-        google_cse_id=tool['settings'].get("google_cse_id"),
+        browser_configuration=tool['settings']['browser_configuration'],
         toolkit_name=tool.get('toolkit_name', '')
     ).get_tools()
 
@@ -42,8 +42,9 @@ class BrowserToolkit(BaseToolkit):
 
         def validate_google_fields(cls, values):
             if 'google' in values.get('selected_tools', []):
-                google_cse_id = values.get('google_cse_id') is not None
-                google_api_key = values.get('google_api_key') is not None
+                browser_config = values.get('browser_configuration', {})
+                google_cse_id = browser_config.get('google_cse_id') is not None if browser_config else False
+                google_api_key = browser_config.get('google_api_key') is not None if browser_config else False
                 if not (google_cse_id and google_api_key):
                     raise ValueError("google_cse_id and google_api_key are required when 'google' is in selected_tools")
             return values
@@ -51,9 +52,7 @@ class BrowserToolkit(BaseToolkit):
         return create_model(
             name,
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Browser", "icon_url": None, "categories": ["testing"], "extra_categories": ["web scraping", "search", "crawler"]}}),
-            google_cse_id=(Optional[str], Field(description="Google CSE id", default=None)),
-            google_api_key=(Optional[SecretStr],
-                            Field(description="Google API key", default=None, json_schema_extra={'secret': True})),
+            browser_configuration=(BrowserConfiguration, Field(description="Browser Configuration", json_schema_extra={'configuration_types': ['browser']})),
             selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __validators__={
@@ -65,6 +64,12 @@ class BrowserToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
+
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('browser_configuration', {}),
+        }
+
         tools = []
         prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         if not selected_tools:
@@ -88,8 +93,7 @@ class BrowserToolkit(BaseToolkit):
             elif tool == 'google':
                 try:
                     google_api_wrapper = GoogleSearchAPIWrapper(
-                        google_api_key=kwargs.get("google_api_key"),
-                        google_cse_id=kwargs.get("google_cse_id"),
+                        **wrapper_payload
                     )
                     tool_entry = GoogleSearchResults(api_wrapper=google_api_wrapper)
                     # rename the tool to avoid conflicts