`langchain_community.tools.sleep.tool`.SleepTool¶

注意 (Note)

SleepTool 實現了標準的 Runnable 接口。 🏃

Runnable 接口 還有在可運行對象上可用的其他方法，例如 with_types、with_retry、assign、bind、get_graph 等。

class langchain_community.tools.sleep.tool.SleepTool[源代碼]¶

基類： BaseTool

添加睡眠功能的工具。

初始化工具。

param args_schema: Type[BaseModel] = <class 'langchain_community.tools.sleep.tool.SleepInput'>¶

Pydantic 模型類，用於驗證和解析工具的輸入參數。

參數模式應該是

pydantic.BaseModel 的子類。

或 - pydantic.v1.BaseModel 的子類（如果在 pydantic 2 中訪問 v1 命名空間）

param callback_manager: Optional[BaseCallbackManager] = None¶: 已棄用。請使用 callbacks 代替。

param callbacks: Callbacks = None¶: 在工具執行期間要調用的回調。

param description: str = '使 agent 休眠指定的秒數。'¶

用於告知模型如何/何時/為何使用該工具。

您可以提供少樣本示例作為描述的一部分。

param handle_tool_error: Optional[Union[bool, str, Callable[[ToolException], str]]] = False¶: 處理拋出的 ToolException 的內容。

param handle_validation_error: Optional[Union[bool, str, Callable[[ValidationError], str]]] = False¶: 處理拋出的 ValidationError 的內容。

param metadata: Optional[Dict[str, Any]] = None¶: 與工具關聯的可選元數據。默認為 None。此元數據將與每次工具調用關聯，並作為參數傳遞給 callbacks 中定義的處理程序。您可以使用這些元數據來識別工具的特定實例及其用例，例如。

param response_format: Literal['content', 'content_and_artifact'] = 'content'¶

工具響應格式。默認為 ‘content’。

如果是 “content”，則工具的輸出將被解釋為 ToolMessage 的內容。如果是 “content_and_artifact”，則預期輸出是一個雙元組，對應於 ToolMessage 的（內容，工件）。

param return_direct: bool = False¶

是否直接返回工具的輸出。

將此項設置為 True 意味著在調用工具後，AgentExecutor 將停止循環。

param tags: Optional[List[str]] = None¶: 與工具關聯的可選標籤列表。默認為 None。這些標籤將與每次工具調用關聯，並作為參數傳遞給 callbacks 中定義的處理程序。您可以使用這些標籤來識別工具的特定實例及其用例，例如。

param verbose: bool = False¶: 是否記錄工具的進度。

__call__(tool_input: str, callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None) → str¶

在 langchain-core==0.1.47 版本中已棄用: 使用 invoke 代替。

使工具可調用。

參數 (Parameters)

tool_input (str) –
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) –

返回類型 (Return type)

str

async abatch(inputs: List[Input], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → List[Output]¶

默認實現使用 asyncio.gather 並行運行 ainvoke。

batch 的默認實現對於 IO 綁定的可運行對象效果良好。

子類應該重寫此方法，如果它們可以更有效地批量處理；例如，如果底層 Runnable 使用支持批量模式的 API。

參數 (Parameters)

inputs (List[Input]) – Runnable 的輸入列表。
config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) – 調用 Runnable 時使用的配置。該配置支持標準鍵，如用於追蹤目的的 ‘tags’、‘metadata’，用於控制並行執行工作量的 ‘max_concurrency’，以及其他鍵。請參考 RunnableConfig 了解更多詳情。默認為 None。
return_exceptions (bool) – 是否返回異常而不是引發它們。默認為 False。
kwargs (Optional[Any]) – 要傳遞給 Runnable 的其他關鍵字參數。

返回 (Returns)

Runnable 的輸出列表。

返回類型 (Return type)

List[Output]

async abatch_as_completed(inputs: Sequence[Input], config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → AsyncIterator[Tuple[int, Union[Output, Exception]]]¶

並行運行 ainvoke 在輸入列表上，在結果完成時產生結果。

參數 (Parameters)

inputs (Sequence[Input]) – Runnable 的輸入列表。
config (Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]) – 調用 Runnable 時使用的配置。該配置支持標準鍵，如用於追蹤目的的 ‘tags’、‘metadata’，用於控制並行執行工作量的 ‘max_concurrency’，以及其他鍵。請參考 RunnableConfig 了解更多詳情。默認為 None。默認為 None。
return_exceptions (bool) – 是否返回異常而不是引發它們。默認為 False。
kwargs (Optional[Any]) – 要傳遞給 Runnable 的其他關鍵字參數。

產生 (Yields)

輸入索引和 Runnable 輸出的元組。

返回類型 (Return type)

AsyncIterator[Tuple[int, Union[Output, Exception]]]

async ainvoke(input: Union[str, Dict, ToolCall], config: Optional[RunnableConfig] = None, **kwargs: Any) → Any¶

ainvoke 的默認實現，從線程調用 invoke。

即使 Runnable 沒有實現 invoke 的原生異步版本，默認實現也允許使用異步代碼。

子類應該重寫此方法，如果它們可以異步運行。

參數 (Parameters)

input (Union[str, Dict, ToolCall]) –
config (Optional[RunnableConfig]) –
kwargs (Any) –

返回類型 (Return type)

Any

async arun(tool_input: Union[str, Dict], verbose: Optional[bool] = None, start_color: Optional[str] = 'green', color: Optional[str] = 'green', callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, run_name: Optional[str] = None, run_id: Optional[UUID] = None, config: Optional[RunnableConfig] = None, tool_call_id: Optional[str] = None, **kwargs: Any) → Any¶

異步運行工具。

參數 (Parameters)

tool_input (Union[str, Dict]) – 工具的輸入。
verbose (Optional[bool]) – 是否記錄工具的進度。默認為 None。
start_color (Optional[str]) – 啟動工具時使用的顏色。默認為 ‘green’。
color (Optional[str]) – 結束工具時使用的顏色。默認為 ‘green’。
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 在工具執行期間要調用的回調。默認為 None。
tags (Optional[List[str]]) – 與工具關聯的可選標籤列表。默認為 None。
metadata (Optional[Dict[str, Any]]) – 與工具關聯的可選元數據。默認為 None。
run_name (Optional[str]) – 運行的名稱。默認為 None。
run_id (Optional[UUID]) – 運行的 ID。默認為 None。
config (Optional[RunnableConfig]) – 工具的配置。默認為 None。
tool_call_id (Optional[str]) – 工具調用的 ID。默認為 None。
kwargs (Any) – 要傳遞給工具的其他參數

返回 (Returns)

工具的輸出。

引發 (Raises)

ToolException – 如果工具执行期间发生错误。

返回類型 (Return type)

Any

as_tool(args_schema: Optional[Type[BaseModel]] = None, *, name: Optional[str] = None, description: Optional[str] = None, arg_types: Optional[Dict[str, Type]] = None) → BaseTool¶

Beta

此 API 处于 Beta 阶段，未来可能会发生更改。

从 Runnable 创建一个 BaseTool。

as_tool 将从 Runnable 实例化一个具有名称、描述和 args_schema 的 BaseTool。在可能的情况下，模式从 runnable.get_input_schema 推断。或者（例如，如果 Runnable 接受 dict 作为输入，并且未键入特定的 dict 键），可以直接使用 args_schema 指定模式。您也可以传递 arg_types 以仅指定必需的参数及其类型。

參數 (Parameters)

args_schema (Optional[Type[BaseModel]]) – 工具的模式。默认为 None。
name (Optional[str]) – 工具的名称。默认为 None。
description (Optional[str]) – 工具的描述。默认为 None。
arg_types (Optional[Dict[str, Type]]) – 参数名称到类型的字典。默认为 None。

返回 (Returns)

一个 BaseTool 实例。

返回類型 (Return type)

BaseTool

Typed dict input (类型化的字典输入)

from typing import List
from typing_extensions import TypedDict
from langchain_core.runnables import RunnableLambda

class Args(TypedDict):
    a: int
    b: List[int]

def f(x: Args) -> str:
    return str(x["a"] * max(x["b"]))

runnable = RunnableLambda(f)
as_tool = runnable.as_tool()
as_tool.invoke({"a": 3, "b": [1, 2]})

dict input，通过 args_schema 指定模式

from typing import Any, Dict, List
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_core.runnables import RunnableLambda

def f(x: Dict[str, Any]) -> str:
    return str(x["a"] * max(x["b"]))

class FSchema(BaseModel):
    """Apply a function to an integer and list of integers."""

    a: int = Field(..., description="Integer")
    b: List[int] = Field(..., description="List of ints")

runnable = RunnableLambda(f)
as_tool = runnable.as_tool(FSchema)
as_tool.invoke({"a": 3, "b": [1, 2]})

dict input，通过 arg_types 指定模式

from typing import Any, Dict, List
from langchain_core.runnables import RunnableLambda

def f(x: Dict[str, Any]) -> str:
    return str(x["a"] * max(x["b"]))

runnable = RunnableLambda(f)
as_tool = runnable.as_tool(arg_types={"a": int, "b": List[int]})
as_tool.invoke({"a": 3, "b": [1, 2]})

String input (字符串输入)

from langchain_core.runnables import RunnableLambda

def f(x: str) -> str:
    return x + "a"

def g(x: str) -> str:
    return x + "z"

runnable = RunnableLambda(f) | g
as_tool = runnable.as_tool()
as_tool.invoke("b")

0.2.14 版本新增功能。

async astream(input: Input, config: Optional[RunnableConfig] = None, **kwargs: Optional[Any]) → AsyncIterator[Output]¶

astream 的默认实现，它调用 ainvoke。如果子类支持流式输出，则应重写此方法。

參數 (Parameters)

input (Input) – Runnable 的输入。
config (Optional[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。
kwargs (Optional[Any]) – 要傳遞給 Runnable 的其他關鍵字參數。

產生 (Yields)

Runnable 的输出。

返回類型 (Return type)

AsyncIterator[Output]

astream_events(input: Any, config: Optional[RunnableConfig] = None, *, version: Literal['v1', 'v2'], include_names: Optional[Sequence[str]] = None, include_types: Optional[Sequence[str]] = None, include_tags: Optional[Sequence[str]] = None, exclude_names: Optional[Sequence[str]] = None, exclude_types: Optional[Sequence[str]] = None, exclude_tags: Optional[Sequence[str]] = None, **kwargs: Any) → AsyncIterator[Union[StandardStreamEvent, CustomStreamEvent]]¶

Beta

此 API 处于 Beta 阶段，未来可能会发生更改。

生成事件流。

用于创建一个迭代器，遍历 StreamEvents，这些 StreamEvents 提供关于 Runnable 进度的实时信息，包括来自中间结果的 StreamEvents。

StreamEvent 是一个具有以下模式的字典

event: str - 事件名称的格式为：
format: on_[runnable_type]_(start|stream|end)。
name: str - 生成事件的 Runnable 的名称。
run_id: str - 随机生成的 ID，与发出事件的 Runnable 的给定执行相关联。作为父 Runnable 执行的一部分被调用的子 Runnable 将被分配其自己的唯一 ID。
the Runnable that emitted the event. A child Runnable that gets invoked as part of the execution of a parent Runnable is assigned its own unique ID.
parent_ids: List[str] - 生成事件的父 runnables 的 ID。根 Runnable 将有一个空列表。父 ID 的顺序是从根到直接父级。仅适用于 API 的 v2 版本。 API 的 v1 版本将返回一个空列表。
generated the event. The root Runnable will have an empty list. The order of the parent IDs is from the root to the immediate parent. Only available for v2 version of the API. The v1 version of the API will return an empty list.
tags: Optional[List[str]] - 生成事件的 Runnable 的标签。
the event.
metadata: Optional[Dict[str, Any]] - 生成事件的 Runnable 的元数据。
that generated the event.
data: Dict[str, Any]

下面是一个表格，说明了各种链可能发出的一些事件。为了简洁起见，元数据字段已从表格中省略。链定义已包含在表格之后。

注意此参考表适用于 V2 版本的模式。

event	name	chunk	input	output
on_chat_model_start	[model name]		{“messages”: [[SystemMessage, HumanMessage]]}
on_chat_model_stream	[model name]	AIMessageChunk(content=”hello”)
on_chat_model_end	[model name]		{“messages”: [[SystemMessage, HumanMessage]]}	AIMessageChunk(content=”hello world”)
on_llm_start	[model name]		{‘input’: ‘hello’}
on_llm_stream	[model name]	‘Hello’
on_llm_end	[model name]		‘Hello human!’
on_chain_start	format_docs
on_chain_stream	format_docs	“hello world!, goodbye world!”
on_chain_end	format_docs		[Document(…)]	“hello world!, goodbye world!”
on_tool_start	some_tool		{“x”: 1, “y”: “2”}
on_tool_end	some_tool			{“x”: 1, “y”: “2”}
on_retriever_start	[retriever name]		{“query”: “hello”}
on_retriever_end	[retriever name]		{“query”: “hello”}	[Document(…), ..]
on_prompt_start	[template_name]		{“question”: “hello”}
on_prompt_end	[template_name]		{“question”: “hello”}	ChatPromptValue(messages: [SystemMessage, …])

除了标准事件之外，用户还可以调度自定义事件（请参阅下面的示例）。

自定义事件将仅在 v2 版本的 API 中显示！

自定义事件具有以下格式

Attribute (属性)	Type (类型)	Description (描述)
name	str	事件的用户定义名称。
data	Any	与事件关联的数据。这可以是任何内容，但我们建议使其可 JSON 序列化。

以下是与上面显示的标准事件关联的声明

format_docs:

def format_docs(docs: List[Document]) -> str:
    '''Format the docs.'''
    return ", ".join([doc.page_content for doc in docs])

format_docs = RunnableLambda(format_docs)

some_tool:

@tool
def some_tool(x: int, y: str) -> dict:
    '''Some_tool.'''
    return {"x": x, "y": y}

prompt:

template = ChatPromptTemplate.from_messages(
    [("system", "You are Cat Agent 007"), ("human", "{question}")]
).with_config({"run_name": "my_template", "tags": ["my_template"]})

示例

from langchain_core.runnables import RunnableLambda

async def reverse(s: str) -> str:
    return s[::-1]

chain = RunnableLambda(func=reverse)

events = [
    event async for event in chain.astream_events("hello", version="v2")
]

# will produce the following events (run_id, and parent_ids
# has been omitted for brevity):
[
    {
        "data": {"input": "hello"},
        "event": "on_chain_start",
        "metadata": {},
        "name": "reverse",
        "tags": [],
    },
    {
        "data": {"chunk": "olleh"},
        "event": "on_chain_stream",
        "metadata": {},
        "name": "reverse",
        "tags": [],
    },
    {
        "data": {"output": "olleh"},
        "event": "on_chain_end",
        "metadata": {},
        "name": "reverse",
        "tags": [],
    },
]

示例：调度自定义事件

from langchain_core.callbacks.manager import (
    adispatch_custom_event,
)
from langchain_core.runnables import RunnableLambda, RunnableConfig
import asyncio


async def slow_thing(some_input: str, config: RunnableConfig) -> str:
    """Do something that takes a long time."""
    await asyncio.sleep(1) # Placeholder for some slow operation
    await adispatch_custom_event(
        "progress_event",
        {"message": "Finished step 1 of 3"},
        config=config # Must be included for python < 3.10
    )
    await asyncio.sleep(1) # Placeholder for some slow operation
    await adispatch_custom_event(
        "progress_event",
        {"message": "Finished step 2 of 3"},
        config=config # Must be included for python < 3.10
    )
    await asyncio.sleep(1) # Placeholder for some slow operation
    return "Done"

slow_thing = RunnableLambda(slow_thing)

async for event in slow_thing.astream_events("some_input", version="v2"):
    print(event)

參數 (Parameters)

input (Any) – Runnable 的输入。
config (Optional[RunnableConfig]) – 用于 Runnable 的配置。
version (Literal['v1', 'v2']) – 要使用的模式版本，v2 或 v1。用户应使用 v2。v1 用于向后兼容，将在 0.4.0 中弃用。在 API 稳定之前，不会分配默认值。自定义事件将仅在 v2 中显示。
include_names (Optional[Sequence[str]]) – 仅包括来自具有匹配名称的 runnables 的事件。
include_types (Optional[Sequence[str]]) – 仅包括来自具有匹配类型的 runnables 的事件。
include_tags (Optional[Sequence[str]]) – 仅包括来自具有匹配标签的 runnables 的事件。
exclude_names (Optional[Sequence[str]]) – 排除来自具有匹配名称的 runnables 的事件。
exclude_types (Optional[Sequence[str]]) – 排除来自具有匹配类型的 runnables 的事件。
exclude_tags (Optional[Sequence[str]]) – 排除来自具有匹配标签的 runnables 的事件。
kwargs (Any) – 要传递给 Runnable 的其他关键字参数。这些将传递给 astream_log，因为此 astream_events 的实现构建在 astream_log 之上。

產生 (Yields)

StreamEvents 的异步流。

引發 (Raises)

NotImplementedError – 如果版本不是 v1 或 v2。

返回類型 (Return type)

AsyncIterator[Union[StandardStreamEvent, CustomStreamEvent]]

batch(inputs: List[Input], config: Optional[Union[RunnableConfig, List[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → List[Output]¶

默认实现使用线程池执行器并行运行 invoke。

batch 的默認實現對於 IO 綁定的可運行對象效果良好。

子類應該重寫此方法，如果它們可以更有效地批量處理；例如，如果底層 Runnable 使用支持批量模式的 API。

參數 (Parameters)

inputs (List[Input]) –
config (Optional[Union[RunnableConfig, List[RunnableConfig]]]) –
return_exceptions (bool) –
kwargs (Optional[Any]) –

返回類型 (Return type)

List[Output]

batch_as_completed(inputs: Sequence[Input], config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None, *, return_exceptions: bool = False, **kwargs: Optional[Any]) → Iterator[Tuple[int, Union[Output, Exception]]]¶

并行运行列表中输入的 invoke，并在完成时生成结果。

參數 (Parameters)

inputs (Sequence[Input]) –
config (Optional[Union[RunnableConfig, Sequence[RunnableConfig]]]) –
return_exceptions (bool) –
kwargs (Optional[Any]) –

返回類型 (Return type)

Iterator[Tuple[int, Union[Output, Exception]]]

configurable_alternatives(which: ConfigurableField, *, default_key: str = 'default', prefix_keys: bool = False, **kwargs: Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]]) → RunnableSerializable[Input, Output]¶

配置可在运行时设置的 Runnables 的备选项。

參數 (Parameters)

which (ConfigurableField) – 将用于选择备选项的 ConfigurableField 实例。
default_key (str) – 如果未选择备选项，则使用的默认键。默认为 “default”。
prefix_keys (bool) – 是否使用 ConfigurableField id 作为键的前缀。默认为 False。
**kwargs (Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]]) – 键到 Runnable 实例或返回 Runnable 实例的可调用对象的字典。

返回 (Returns)

配置了备选项的新 Runnable。

返回類型 (Return type)

RunnableSerializable[Input, Output]

from langchain_anthropic import ChatAnthropic
from langchain_core.runnables.utils import ConfigurableField
from langchain_openai import ChatOpenAI

model = ChatAnthropic(
    model_name="claude-3-sonnet-20240229"
).configurable_alternatives(
    ConfigurableField(id="llm"),
    default_key="anthropic",
    openai=ChatOpenAI()
)

# uses the default model ChatAnthropic
print(model.invoke("which organization created you?").content)

# uses ChatOpenAI
print(
    model.with_config(
        configurable={"llm": "openai"}
    ).invoke("which organization created you?").content
)

configurable_fields(**kwargs: Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) → RunnableSerializable[Input, Output]¶

在运行时配置特定的 Runnable 字段。

參數 (Parameters): **kwargs (Union[ConfigurableField, ConfigurableFieldSingleOption, ConfigurableFieldMultiOption]) – 要配置的 ConfigurableField 实例的字典。
返回 (Returns): 配置了字段的新 Runnable。
返回類型 (Return type): RunnableSerializable[Input, Output]

from langchain_core.runnables import ConfigurableField
from langchain_openai import ChatOpenAI

model = ChatOpenAI(max_tokens=20).configurable_fields(
    max_tokens=ConfigurableField(
        id="output_token_number",
        name="Max tokens in the output",
        description="The maximum number of tokens in the output",
    )
)

# max_tokens = 20
print(
    "max_tokens_20: ",
    model.invoke("tell me something about chess").content
)

# max_tokens = 200
print("max_tokens_200: ", model.with_config(
    configurable={"output_token_number": 200}
    ).invoke("tell me something about chess").content
)

invoke(input: Union[str, Dict, ToolCall], config: Optional[RunnableConfig] = None, **kwargs: Any) → Any¶

将单个输入转换为输出。重写以实现。

參數 (Parameters)

input (Union[str, Dict, ToolCall]) – Runnable 的输入。
config (Optional[RunnableConfig]) – 调用 Runnable 时使用的配置。该配置支持标准键，例如用于跟踪目的的 ‘tags’、‘metadata’，用于控制并行执行量的 ‘max_concurrency’ 以及其他键。请参阅 RunnableConfig 以获取更多详细信息。
kwargs (Any) –

返回 (Returns)

Runnable 的输出。

返回類型 (Return type)

Any

run(tool_input: Union[str, Dict[str, Any]], verbose: Optional[bool] = None, start_color: Optional[str] = 'green', color: Optional[str] = 'green', callbacks: Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] = None, *, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, run_name: Optional[str] = None, run_id: Optional[UUID] = None, config: Optional[RunnableConfig] = None, tool_call_id: Optional[str] = None, **kwargs: Any) → Any¶

运行该工具。

參數 (Parameters)

tool_input (Union[str, Dict[str, Any]]) – 工具的输入。
verbose (Optional[bool]) – 是否記錄工具的進度。默認為 None。
start_color (Optional[str]) – 啟動工具時使用的顏色。默認為 ‘green’。
color (Optional[str]) – 結束工具時使用的顏色。默認為 ‘green’。
callbacks (Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]) – 在工具執行期間要調用的回調。默認為 None。
tags (Optional[List[str]]) – 與工具關聯的可選標籤列表。默認為 None。
metadata (Optional[Dict[str, Any]]) – 與工具關聯的可選元數據。默認為 None。
run_name (Optional[str]) – 運行的名稱。默認為 None。
run_id (Optional[UUID]) – 運行的 ID。默認為 None。
config (Optional[RunnableConfig]) – 工具的配置。默認為 None。
tool_call_id (Optional[str]) – 工具調用的 ID。默認為 None。
kwargs (Any) – 要傳遞給工具的其他參數

返回 (Returns)

工具的輸出。

引發 (Raises)

ToolException – 如果工具执行期间发生错误。

返回類型 (Return type)

Any

stream(input: Input, config: Optional[RunnableConfig] = None, **kwargs: Optional[Any]) → Iterator[Output]¶

stream 的默认实现，它调用 invoke。如果子类支持流式输出，则应重写此方法。

參數 (Parameters)

input (Input) – Runnable 的输入。
config (Optional[RunnableConfig]) – 用于 Runnable 的配置。默认为 None。
kwargs (Optional[Any]) – 要傳遞給 Runnable 的其他關鍵字參數。

產生 (Yields)

Runnable 的输出。

返回類型 (Return type)

Iterator[Output]

to_json() → Union[SerializedConstructor, SerializedNotImplemented]¶

将 Runnable 序列化为 JSON。

返回 (Returns): Runnable 的 JSON 可序列化表示形式。
返回類型 (Return type): Union[SerializedConstructor, SerializedNotImplemented]

property args: dict¶

property is_single_input: bool¶: 该工具是否仅接受单个输入。

property tool_call_schema: Type[BaseModel]¶

langchain_community.tools.sleep.tool.SleepTool¶

`langchain_community.tools.sleep.tool`.SleepTool¶