feat(toolbox-langchain)!: Base toolbox-langchain over toolbox-core

packages/toolbox-core/src/toolbox_core/sync_client.py

@@ -56,7 +56,6 @@ def __init__(
         async def create_client():
             return ToolboxClient(url, client_headers=client_headers)
 
-        # Ignoring type since we're already checking the existence of a loop above.
         self.__async_client = asyncio.run_coroutine_threadsafe(
             create_client(), self.__class__.__loop
         ).result()

packages/toolbox-langchain/README.md

@@ -227,7 +227,7 @@ tools = toolbox.load_toolset()
 
 auth_tool = tools[0].add_auth_token_getter("my_auth", get_auth_token) # Single token
 
-multi_auth_tool = tools[0].add_auth_token_getters({"my_auth", get_auth_token}) # Multiple tokens
+multi_auth_tool = tools[0].add_auth_token_getters({"auth_1": get_auth_1}, {"auth_2": get_auth_2}) # Multiple tokens
 
 # OR
 

packages/toolbox-langchain/integration.cloudbuild.yaml

@@ -15,10 +15,11 @@
 steps:
   - id: Install library requirements
     name: 'python:${_VERSION}'
+    dir: 'packages/toolbox-langchain'
     args:
       - install
       - '-r'
-      - 'packages/toolbox-langchain/requirements.txt'
+      - 'requirements.txt'
       - '--user'
     entrypoint: pip
   - id: Install test requirements

packages/toolbox-langchain/pyproject.toml

@@ -9,6 +9,8 @@ authors = [
     {name = "Google LLC", email = "googleapis-packages@google.com"}
 ]
 dependencies = [
+    # TODO: Bump lowest supported version to 0.2.0
+    "toolbox-core>=0.1.0,<1.0.0",
     "langchain-core>=0.2.23,<1.0.0",
     "PyYAML>=6.0.1,<7.0.0",
     "pydantic>=2.7.0,<3.0.0",

packages/toolbox-langchain/requirements.txt

@@ -1,3 +1,4 @@
+-e ../toolbox-core
 langchain-core==0.3.56
 PyYAML==6.0.2
 pydantic==2.11.4

packages/toolbox-langchain/src/toolbox_langchain/async_client.py

@@ -16,9 +16,9 @@
 from warnings import warn
 
 from aiohttp import ClientSession
+from toolbox_core.client import ToolboxClient as ToolboxCoreClient
 
-from .tools import AsyncToolboxTool
-from .utils import ManifestSchema, _load_manifest
+from .async_tools import AsyncToolboxTool
 
 
 # This class is an internal implementation detail and is not exposed to the
@@ -38,8 +38,7 @@ def __init__(
             url: The base URL of the Toolbox service.
             session: An HTTP client session.
         """
-        self.__url = url
-        self.__session = session
+        self.__core_client = ToolboxCoreClient(url=url, session=session)
 
     async def aload_tool(
         self,
@@ -48,7 +47,6 @@ async def aload_tool(
         auth_tokens: Optional[dict[str, Callable[[], str]]] = None,
         auth_headers: Optional[dict[str, Callable[[], str]]] = None,
         bound_params: dict[str, Union[Any, Callable[[], Any]]] = {},
-        strict: bool = True,
     ) -> AsyncToolboxTool:
         """
         Loads the tool with the given tool name from the Toolbox service.
@@ -61,9 +59,6 @@ async def aload_tool(
             auth_headers: Deprecated. Use `auth_token_getters` instead.
             bound_params: An optional mapping of parameter names to their
                 bound values.
-            strict: If True, raises a ValueError if any of the given bound
-                parameters are missing from the schema or require
-                authentication. If False, only issues a warning.
 
         Returns:
             A tool loaded from the Toolbox.
@@ -94,18 +89,12 @@ async def aload_tool(
                 )
                 auth_token_getters = auth_headers
 
-        url = f"{self.__url}/api/tool/{tool_name}"
-        manifest: ManifestSchema = await _load_manifest(url, self.__session)
-
-        return AsyncToolboxTool(
-            tool_name,
-            manifest.tools[tool_name],
-            self.__url,
-            self.__session,
-            auth_token_getters,
-            bound_params,
-            strict,
+        core_tool = await self.__core_client.load_tool(
+            name=tool_name,
+            auth_token_getters=auth_token_getters,
+            bound_params=bound_params,
         )
+        return AsyncToolboxTool(core_tool=core_tool)
 
     async def aload_toolset(
         self,
@@ -114,7 +103,7 @@ async def aload_toolset(
         auth_tokens: Optional[dict[str, Callable[[], str]]] = None,
         auth_headers: Optional[dict[str, Callable[[], str]]] = None,
         bound_params: dict[str, Union[Any, Callable[[], Any]]] = {},
-        strict: bool = True,
+        strict: bool = False,
     ) -> list[AsyncToolboxTool]:
         """
         Loads tools from the Toolbox service, optionally filtered by toolset
@@ -129,9 +118,11 @@ async def aload_toolset(
             auth_headers: Deprecated. Use `auth_token_getters` instead.
             bound_params: An optional mapping of parameter names to their
                 bound values.
-            strict: If True, raises a ValueError if any of the given bound
-                parameters are missing from the schema or require
-                authentication. If False, only issues a warning.
+            strict: If True, raises an error if *any* loaded tool instance fails
+                to utilize at least one provided parameter or auth token (if any
+                provided). If False (default), raises an error only if a
+                user-provided parameter or auth token cannot be applied to *any*
+                loaded tool across the set.
 
         Returns:
             A list of all tools loaded from the Toolbox.
@@ -162,22 +153,16 @@ async def aload_toolset(
                 )
                 auth_token_getters = auth_headers
 
-        url = f"{self.__url}/api/toolset/{toolset_name or ''}"
-        manifest: ManifestSchema = await _load_manifest(url, self.__session)
-        tools: list[AsyncToolboxTool] = []
-
-        for tool_name, tool_schema in manifest.tools.items():
-            tools.append(
-                AsyncToolboxTool(
-                    tool_name,
-                    tool_schema,
-                    self.__url,
-                    self.__session,
-                    auth_token_getters,
-                    bound_params,
-                    strict,
-                )
-            )
+        core_tools = await self.__core_client.load_toolset(
+            name=toolset_name,
+            auth_token_getters=auth_token_getters,
+            bound_params=bound_params,
+            strict=strict,
+        )
+
+        tools = []
+        for core_tool in core_tools:
+            tools.append(AsyncToolboxTool(core_tool=core_tool))
         return tools
 
     def load_tool(
@@ -187,7 +172,6 @@ def load_tool(
         auth_tokens: Optional[dict[str, Callable[[], str]]] = None,
         auth_headers: Optional[dict[str, Callable[[], str]]] = None,
         bound_params: dict[str, Union[Any, Callable[[], Any]]] = {},
-        strict: bool = True,
     ) -> AsyncToolboxTool:
         raise NotImplementedError("Synchronous methods not supported by async client.")
 
@@ -198,6 +182,6 @@ def load_toolset(
         auth_tokens: Optional[dict[str, Callable[[], str]]] = None,
         auth_headers: Optional[dict[str, Callable[[], str]]] = None,
         bound_params: dict[str, Union[Any, Callable[[], Any]]] = {},
-        strict: bool = True,
+        strict: bool = False,
     ) -> list[AsyncToolboxTool]:
         raise NotImplementedError("Synchronous methods not supported by async client.")