pydantic-ai-slim 0.6.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

pydantic_ai/durable_exec/temporal/_function_toolset.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Literal
+
+from pydantic import ConfigDict, with_config
+from temporalio import activity, workflow
+from temporalio.workflow import ActivityConfig
+
+from pydantic_ai.exceptions import UserError
+from pydantic_ai.tools import AgentDepsT, RunContext
+from pydantic_ai.toolsets import FunctionToolset, ToolsetTool
+from pydantic_ai.toolsets.function import FunctionToolsetTool
+
+from ._run_context import TemporalRunContext
+from ._toolset import TemporalWrapperToolset
+
+
+@dataclass
+@with_config(ConfigDict(arbitrary_types_allowed=True))
+class _CallToolParams:
+    name: str
+    tool_args: dict[str, Any]
+    serialized_run_context: Any
+
+
+class TemporalFunctionToolset(TemporalWrapperToolset[AgentDepsT]):
+    def __init__(
+        self,
+        toolset: FunctionToolset[AgentDepsT],
+        *,
+        activity_name_prefix: str,
+        activity_config: ActivityConfig,
+        tool_activity_config: dict[str, ActivityConfig | Literal[False]],
+        deps_type: type[AgentDepsT],
+        run_context_type: type[TemporalRunContext[AgentDepsT]] = TemporalRunContext[AgentDepsT],
+    ):
+        super().__init__(toolset)
+        self.activity_config = activity_config
+        self.tool_activity_config = tool_activity_config
+        self.run_context_type = run_context_type
+
+        async def call_tool_activity(params: _CallToolParams, deps: AgentDepsT) -> Any:
+            name = params.name
+            ctx = self.run_context_type.deserialize_run_context(params.serialized_run_context, deps=deps)
+            try:
+                tool = (await toolset.get_tools(ctx))[name]
+            except KeyError as e:  # pragma: no cover
+                raise UserError(
+                    f'Tool {name!r} not found in toolset {self.id!r}. '
+                    'Removing or renaming tools during an agent run is not supported with Temporal.'
+                ) from e
+
+            return await self.wrapped.call_tool(name, params.tool_args, ctx, tool)
+
+        # Set type hint explicitly so that Temporal can take care of serialization and deserialization
+        call_tool_activity.__annotations__['deps'] = deps_type
+
+        self.call_tool_activity = activity.defn(name=f'{activity_name_prefix}__toolset__{self.id}__call_tool')(
+            call_tool_activity
+        )
+
+    @property
+    def temporal_activities(self) -> list[Callable[..., Any]]:
+        return [self.call_tool_activity]
+
+    async def call_tool(
+        self, name: str, tool_args: dict[str, Any], ctx: RunContext[AgentDepsT], tool: ToolsetTool[AgentDepsT]
+    ) -> Any:
+        if not workflow.in_workflow():
+            return await super().call_tool(name, tool_args, ctx, tool)
+
+        tool_activity_config = self.tool_activity_config.get(name, {})
+        if tool_activity_config is False:
+            assert isinstance(tool, FunctionToolsetTool)
+            if not tool.is_async:
+                raise UserError(
+                    f'Temporal activity config for tool {name!r} has been explicitly set to `False` (activity disabled), '
+                    'but non-async tools are run in threads which are not supported outside of an activity. Make the tool function async instead.'
+                )
+            return await super().call_tool(name, tool_args, ctx, tool)
+
+        tool_activity_config = self.activity_config | tool_activity_config
+        serialized_run_context = self.run_context_type.serialize_run_context(ctx)
+        return await workflow.execute_activity(  # pyright: ignore[reportUnknownMemberType]
+            activity=self.call_tool_activity,
+            args=[
+                _CallToolParams(name=name, tool_args=tool_args, serialized_run_context=serialized_run_context),
+                ctx.deps,
+            ],
+            **tool_activity_config,
+        )

pydantic_ai/durable_exec/temporal/_logfire.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from logfire import Logfire
+from opentelemetry.trace import get_tracer
+from temporalio.client import ClientConfig, Plugin as ClientPlugin
+from temporalio.contrib.opentelemetry import TracingInterceptor
+from temporalio.runtime import OpenTelemetryConfig, Runtime, TelemetryConfig
+from temporalio.service import ConnectConfig, ServiceClient
+
+
+def _default_setup_logfire() -> Logfire:
+    import logfire
+
+    instance = logfire.configure()
+    logfire.instrument_pydantic_ai()
+    return instance
+
+
+class LogfirePlugin(ClientPlugin):
+    """Temporal client plugin for Logfire."""
+
+    def __init__(self, setup_logfire: Callable[[], Logfire] = _default_setup_logfire, *, metrics: bool = True):
+        self.setup_logfire = setup_logfire
+        self.metrics = metrics
+
+    def configure_client(self, config: ClientConfig) -> ClientConfig:
+        interceptors = config.get('interceptors', [])
+        config['interceptors'] = [*interceptors, TracingInterceptor(get_tracer('temporalio'))]
+        return super().configure_client(config)
+
+    async def connect_service_client(self, config: ConnectConfig) -> ServiceClient:
+        logfire = self.setup_logfire()
+
+        if self.metrics:
+            logfire_config = logfire.config
+            token = logfire_config.token
+            if logfire_config.send_to_logfire and token is not None and logfire_config.metrics is not False:
+                base_url = logfire_config.advanced.generate_base_url(token)
+                metrics_url = base_url + '/v1/metrics'
+                headers = {'Authorization': f'Bearer {token}'}
+
+                config.runtime = Runtime(
+                    telemetry=TelemetryConfig(metrics=OpenTelemetryConfig(url=metrics_url, headers=headers))
+                )
+
+        return await super().connect_service_client(config)

pydantic_ai/durable_exec/temporal/_mcp_server.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Literal
+
+from pydantic import ConfigDict, with_config
+from temporalio import activity, workflow
+from temporalio.workflow import ActivityConfig
+from typing_extensions import Self
+
+from pydantic_ai.exceptions import UserError
+from pydantic_ai.mcp import MCPServer, ToolResult
+from pydantic_ai.tools import AgentDepsT, RunContext, ToolDefinition
+from pydantic_ai.toolsets.abstract import ToolsetTool
+
+from ._run_context import TemporalRunContext
+from ._toolset import TemporalWrapperToolset
+
+
+@dataclass
+@with_config(ConfigDict(arbitrary_types_allowed=True))
+class _GetToolsParams:
+    serialized_run_context: Any
+
+
+@dataclass
+@with_config(ConfigDict(arbitrary_types_allowed=True))
+class _CallToolParams:
+    name: str
+    tool_args: dict[str, Any]
+    serialized_run_context: Any
+    tool_def: ToolDefinition
+
+
+class TemporalMCPServer(TemporalWrapperToolset[AgentDepsT]):
+    def __init__(
+        self,
+        server: MCPServer,
+        *,
+        activity_name_prefix: str,
+        activity_config: ActivityConfig,
+        tool_activity_config: dict[str, ActivityConfig | Literal[False]],
+        deps_type: type[AgentDepsT],
+        run_context_type: type[TemporalRunContext[AgentDepsT]] = TemporalRunContext[AgentDepsT],
+    ):
+        super().__init__(server)
+        self.activity_config = activity_config
+
+        self.tool_activity_config: dict[str, ActivityConfig] = {}
+        for tool_name, tool_config in tool_activity_config.items():
+            if tool_config is False:
+                raise UserError(
+                    f'Temporal activity config for MCP tool {tool_name!r} has been explicitly set to `False` (activity disabled), '
+                    'but MCP tools require the use of IO and so cannot be run outside of an activity.'
+                )
+            self.tool_activity_config[tool_name] = tool_config
+
+        self.run_context_type = run_context_type
+
+        async def get_tools_activity(params: _GetToolsParams, deps: AgentDepsT) -> dict[str, ToolDefinition]:
+            run_context = self.run_context_type.deserialize_run_context(params.serialized_run_context, deps=deps)
+            tools = await self.wrapped.get_tools(run_context)
+            # ToolsetTool is not serializable as it holds a SchemaValidator (which is also the same for every MCP tool so unnecessary to pass along the wire every time),
+            # so we just return the ToolDefinitions and wrap them in ToolsetTool outside of the activity.
+            return {name: tool.tool_def for name, tool in tools.items()}
+
+        # Set type hint explicitly so that Temporal can take care of serialization and deserialization
+        get_tools_activity.__annotations__['deps'] = deps_type
+
+        self.get_tools_activity = activity.defn(name=f'{activity_name_prefix}__mcp_server__{self.id}__get_tools')(
+            get_tools_activity
+        )
+
+        async def call_tool_activity(params: _CallToolParams, deps: AgentDepsT) -> ToolResult:
+            run_context = self.run_context_type.deserialize_run_context(params.serialized_run_context, deps=deps)
+            return await self.wrapped.call_tool(
+                params.name,
+                params.tool_args,
+                run_context,
+                self.tool_for_tool_def(params.tool_def),
+            )
+
+        # Set type hint explicitly so that Temporal can take care of serialization and deserialization
+        call_tool_activity.__annotations__['deps'] = deps_type
+
+        self.call_tool_activity = activity.defn(name=f'{activity_name_prefix}__mcp_server__{self.id}__call_tool')(
+            call_tool_activity
+        )
+
+    def tool_for_tool_def(self, tool_def: ToolDefinition) -> ToolsetTool[AgentDepsT]:
+        assert isinstance(self.wrapped, MCPServer)
+        return self.wrapped.tool_for_tool_def(tool_def)
+
+    @property
+    def temporal_activities(self) -> list[Callable[..., Any]]:
+        return [self.get_tools_activity, self.call_tool_activity]
+
+    async def __aenter__(self) -> Self:
+        # The wrapped MCPServer enters itself around listing and calling tools
+        # so we don't need to enter it here (nor could we because we're not inside a Temporal activity).
+        return self
+
+    async def __aexit__(self, *args: Any) -> bool | None:
+        return None
+
+    async def get_tools(self, ctx: RunContext[AgentDepsT]) -> dict[str, ToolsetTool[AgentDepsT]]:
+        if not workflow.in_workflow():
+            return await super().get_tools(ctx)
+
+        serialized_run_context = self.run_context_type.serialize_run_context(ctx)
+        tool_defs = await workflow.execute_activity(  # pyright: ignore[reportUnknownMemberType]
+            activity=self.get_tools_activity,
+            args=[
+                _GetToolsParams(serialized_run_context=serialized_run_context),
+                ctx.deps,
+            ],
+            **self.activity_config,
+        )
+        return {name: self.tool_for_tool_def(tool_def) for name, tool_def in tool_defs.items()}
+
+    async def call_tool(
+        self,
+        name: str,
+        tool_args: dict[str, Any],
+        ctx: RunContext[AgentDepsT],
+        tool: ToolsetTool[AgentDepsT],
+    ) -> ToolResult:
+        if not workflow.in_workflow():
+            return await super().call_tool(name, tool_args, ctx, tool)
+
+        tool_activity_config = self.activity_config | self.tool_activity_config.get(name, {})
+        serialized_run_context = self.run_context_type.serialize_run_context(ctx)
+        return await workflow.execute_activity(  # pyright: ignore[reportUnknownMemberType]
+            activity=self.call_tool_activity,
+            args=[
+                _CallToolParams(
+                    name=name,
+                    tool_args=tool_args,
+                    serialized_run_context=serialized_run_context,
+                    tool_def=tool.tool_def,
+                ),
+                ctx.deps,
+            ],
+            **tool_activity_config,
+        )

pydantic_ai/durable_exec/temporal/_model.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Callable
+
+from pydantic import ConfigDict, with_config
+from temporalio import activity, workflow
+from temporalio.workflow import ActivityConfig
+
+from pydantic_ai.agent import EventStreamHandler
+from pydantic_ai.exceptions import UserError
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelResponse,
+    ModelResponseStreamEvent,
+)
+from pydantic_ai.models import Model, ModelRequestParameters, StreamedResponse
+from pydantic_ai.models.wrapper import WrapperModel
+from pydantic_ai.settings import ModelSettings
+from pydantic_ai.tools import AgentDepsT, RunContext
+from pydantic_ai.usage import Usage
+
+from ._run_context import TemporalRunContext
+
+
+@dataclass
+@with_config(ConfigDict(arbitrary_types_allowed=True))
+class _RequestParams:
+    messages: list[ModelMessage]
+    model_settings: ModelSettings | None
+    model_request_parameters: ModelRequestParameters
+    serialized_run_context: Any
+
+
+class TemporalStreamedResponse(StreamedResponse):
+    def __init__(self, model_request_parameters: ModelRequestParameters, response: ModelResponse):
+        super().__init__(model_request_parameters)
+        self.response = response
+
+    async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
+        return
+        # noinspection PyUnreachableCode
+        yield
+
+    def get(self) -> ModelResponse:
+        return self.response
+
+    def usage(self) -> Usage:
+        return self.response.usage  # pragma: no cover
+
+    @property
+    def model_name(self) -> str:
+        return self.response.model_name or ''  # pragma: no cover
+
+    @property
+    def timestamp(self) -> datetime:
+        return self.response.timestamp  # pragma: no cover
+
+
+class TemporalModel(WrapperModel):
+    def __init__(
+        self,
+        model: Model,
+        *,
+        activity_name_prefix: str,
+        activity_config: ActivityConfig,
+        deps_type: type[AgentDepsT],
+        run_context_type: type[TemporalRunContext[AgentDepsT]] = TemporalRunContext[AgentDepsT],
+        event_stream_handler: EventStreamHandler[Any] | None = None,
+    ):
+        super().__init__(model)
+        self.activity_config = activity_config
+        self.run_context_type = run_context_type
+        self.event_stream_handler = event_stream_handler
+
+        @activity.defn(name=f'{activity_name_prefix}__model_request')
+        async def request_activity(params: _RequestParams) -> ModelResponse:
+            return await self.wrapped.request(params.messages, params.model_settings, params.model_request_parameters)
+
+        self.request_activity = request_activity
+
+        async def request_stream_activity(params: _RequestParams, deps: AgentDepsT) -> ModelResponse:
+            # An error is raised in `request_stream` if no `event_stream_handler` is set.
+            assert self.event_stream_handler is not None
+
+            run_context = self.run_context_type.deserialize_run_context(params.serialized_run_context, deps=deps)
+            async with self.wrapped.request_stream(
+                params.messages, params.model_settings, params.model_request_parameters, run_context
+            ) as streamed_response:
+                await self.event_stream_handler(run_context, streamed_response)
+
+                async for _ in streamed_response:
+                    pass
+            return streamed_response.get()
+
+        # Set type hint explicitly so that Temporal can take care of serialization and deserialization
+        request_stream_activity.__annotations__['deps'] = deps_type
+
+        self.request_stream_activity = activity.defn(name=f'{activity_name_prefix}__model_request_stream')(
+            request_stream_activity
+        )
+
+    @property
+    def temporal_activities(self) -> list[Callable[..., Any]]:
+        return [self.request_activity, self.request_stream_activity]
+
+    async def request(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> ModelResponse:
+        if not workflow.in_workflow():
+            return await super().request(messages, model_settings, model_request_parameters)
+
+        return await workflow.execute_activity(  # pyright: ignore[reportUnknownMemberType]
+            activity=self.request_activity,
+            arg=_RequestParams(
+                messages=messages,
+                model_settings=model_settings,
+                model_request_parameters=model_request_parameters,
+                serialized_run_context=None,
+            ),
+            **self.activity_config,
+        )
+
+    @asynccontextmanager
+    async def request_stream(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+        run_context: RunContext[Any] | None = None,
+    ) -> AsyncIterator[StreamedResponse]:
+        if not workflow.in_workflow():
+            async with super().request_stream(
+                messages, model_settings, model_request_parameters, run_context
+            ) as streamed_response:
+                yield streamed_response
+                return
+
+        if run_context is None:
+            raise UserError(
+                'A Temporal model cannot be used with `pydantic_ai.direct.model_request_stream()` as it requires a `run_context`. Set an `event_stream_handler` on the agent and use `agent.run()` instead.'
+            )
+
+        # We can never get here without an `event_stream_handler`, as `TemporalAgent.run_stream` and `TemporalAgent.iter` raise an error saying to use `TemporalAgent.run` instead,
+        # and that only calls `request_stream` if `event_stream_handler` is set.
+        assert self.event_stream_handler is not None
+
+        serialized_run_context = self.run_context_type.serialize_run_context(run_context)
+        response = await workflow.execute_activity(  # pyright: ignore[reportUnknownMemberType]
+            activity=self.request_stream_activity,
+            args=[
+                _RequestParams(
+                    messages=messages,
+                    model_settings=model_settings,
+                    model_request_parameters=model_request_parameters,
+                    serialized_run_context=serialized_run_context,
+                ),
+                run_context.deps,
+            ],
+            **self.activity_config,
+        )
+        yield TemporalStreamedResponse(model_request_parameters, response)

pydantic_ai/durable_exec/temporal/_run_context.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic_ai.exceptions import UserError
+from pydantic_ai.tools import AgentDepsT, RunContext
+
+
+class TemporalRunContext(RunContext[AgentDepsT]):
+    """The [`RunContext`][pydantic_ai.tools.RunContext] subclass to use to serialize and deserialize the run context for use inside a Temporal activity.
+
+    By default, only the `deps`, `retries`, `tool_call_id`, `tool_name`, `retry` and `run_step` attributes will be available.
+    To make another attribute available, create a `TemporalRunContext` subclass with a custom `serialize_run_context` class method that returns a dictionary that includes the attribute and pass it to [`TemporalAgent`][pydantic_ai.durable_exec.temporal.TemporalAgent].
+    """
+
+    def __init__(self, deps: AgentDepsT, **kwargs: Any):
+        self.__dict__ = {**kwargs, 'deps': deps}
+        setattr(
+            self,
+            '__dataclass_fields__',
+            {name: field for name, field in RunContext.__dataclass_fields__.items() if name in self.__dict__},
+        )
+
+    def __getattribute__(self, name: str) -> Any:
+        try:
+            return super().__getattribute__(name)
+        except AttributeError as e:  # pragma: no cover
+            if name in RunContext.__dataclass_fields__:
+                raise UserError(
+                    f'{self.__class__.__name__!r} object has no attribute {name!r}. '
+                    'To make the attribute available, create a `TemporalRunContext` subclass with a custom `serialize_run_context` class method that returns a dictionary that includes the attribute and pass it to `TemporalAgent`.'
+                )
+            else:
+                raise e
+
+    @classmethod
+    def serialize_run_context(cls, ctx: RunContext[Any]) -> dict[str, Any]:
+        """Serialize the run context to a `dict[str, Any]`."""
+        return {
+            'retries': ctx.retries,
+            'tool_call_id': ctx.tool_call_id,
+            'tool_name': ctx.tool_name,
+            'retry': ctx.retry,
+            'run_step': ctx.run_step,
+        }
+
+    @classmethod
+    def deserialize_run_context(cls, ctx: dict[str, Any], deps: AgentDepsT) -> TemporalRunContext[AgentDepsT]:
+        """Deserialize the run context from a `dict[str, Any]`."""
+        return cls(**ctx, deps=deps)

pydantic_ai/durable_exec/temporal/_toolset.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Literal
+
+from temporalio.workflow import ActivityConfig
+
+from pydantic_ai.mcp import MCPServer
+from pydantic_ai.tools import AgentDepsT
+from pydantic_ai.toolsets.abstract import AbstractToolset
+from pydantic_ai.toolsets.function import FunctionToolset
+from pydantic_ai.toolsets.wrapper import WrapperToolset
+
+from ._run_context import TemporalRunContext
+
+
+class TemporalWrapperToolset(WrapperToolset[AgentDepsT], ABC):
+    @property
+    def id(self) -> str:
+        # An error is raised in `TemporalAgent` if no `id` is set.
+        assert self.wrapped.id is not None
+        return self.wrapped.id
+
+    @property
+    @abstractmethod
+    def temporal_activities(self) -> list[Callable[..., Any]]:
+        raise NotImplementedError
+
+    def visit_and_replace(
+        self, visitor: Callable[[AbstractToolset[AgentDepsT]], AbstractToolset[AgentDepsT]]
+    ) -> AbstractToolset[AgentDepsT]:
+        # Temporalized toolsets cannot be swapped out after the fact.
+        return self
+
+
+def temporalize_toolset(
+    toolset: AbstractToolset[AgentDepsT],
+    activity_name_prefix: str,
+    activity_config: ActivityConfig,
+    tool_activity_config: dict[str, ActivityConfig | Literal[False]],
+    deps_type: type[AgentDepsT],
+    run_context_type: type[TemporalRunContext[AgentDepsT]] = TemporalRunContext[AgentDepsT],
+) -> AbstractToolset[AgentDepsT]:
+    """Temporalize a toolset.
+
+    Args:
+        toolset: The toolset to temporalize.
+        activity_name_prefix: Prefix for Temporal activity names.
+        activity_config: The Temporal activity config to use.
+        tool_activity_config: The Temporal activity config to use for specific tools identified by tool name.
+        deps_type: The type of agent's dependencies object. It needs to be serializable using Pydantic's `TypeAdapter`.
+        run_context_type: The `TemporalRunContext` (sub)class that's used to serialize and deserialize the run context.
+    """
+    if isinstance(toolset, FunctionToolset):
+        from ._function_toolset import TemporalFunctionToolset
+
+        return TemporalFunctionToolset(
+            toolset,
+            activity_name_prefix=activity_name_prefix,
+            activity_config=activity_config,
+            tool_activity_config=tool_activity_config,
+            deps_type=deps_type,
+            run_context_type=run_context_type,
+        )
+    elif isinstance(toolset, MCPServer):
+        from ._mcp_server import TemporalMCPServer
+
+        return TemporalMCPServer(
+            toolset,
+            activity_name_prefix=activity_name_prefix,
+            activity_config=activity_config,
+            tool_activity_config=tool_activity_config,
+            deps_type=deps_type,
+            run_context_type=run_context_type,
+        )
+    else:
+        return toolset

pydantic_ai/ext/aci.py

@@ -1,17 +1,16 @@
-# Checking whether aci-sdk is installed
-try:
-    from aci import ACI
-except ImportError as _import_error:
-    raise ImportError('Please install `aci-sdk` to use ACI.dev tools') from _import_error
+from __future__ import annotations
 
 from collections.abc import Sequence
 from typing import Any
 
-from aci import ACI
-
 from pydantic_ai.tools import Tool
 from pydantic_ai.toolsets.function import FunctionToolset
 
+try:
+    from aci import ACI
+except ImportError as _import_error:
+    raise ImportError('Please install `aci-sdk` to use ACI.dev tools') from _import_error
+
 
 def _clean_schema(schema):
     if isinstance(schema, dict):
@@ -71,5 +70,7 @@ def tool_from_aci(aci_function: str, linked_account_owner_id: str) -> Tool:
 class ACIToolset(FunctionToolset):
     """A toolset that wraps ACI.dev tools."""
 
-    def __init__(self, aci_functions: Sequence[str], linked_account_owner_id: str):
-        super().__init__([tool_from_aci(aci_function, linked_account_owner_id) for aci_function in aci_functions])
+    def __init__(self, aci_functions: Sequence[str], linked_account_owner_id: str, *, id: str | None = None):
+        super().__init__(
+            [tool_from_aci(aci_function, linked_account_owner_id) for aci_function in aci_functions], id=id
+        )

pydantic_ai/ext/langchain.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Any, Protocol
 
 from pydantic.json_schema import JsonSchemaValue
@@ -65,5 +67,5 @@ def tool_from_langchain(langchain_tool: LangChainTool) -> Tool:
 class LangChainToolset(FunctionToolset):
     """A toolset that wraps LangChain tools."""
 
-    def __init__(self, tools: list[LangChainTool]):
-        super().__init__([tool_from_langchain(tool) for tool in tools])
+    def __init__(self, tools: list[LangChainTool], *, id: str | None = None):
+        super().__init__([tool_from_langchain(tool) for tool in tools], id=id)