g3fiBBdZddlZddlmZddlmZmZmZmZm Z ddl m Z m Z m Z ddlmZddlmZddlmZmZdd lmZdd lmZe dd dd d d d dddedzdededzdededdededeeefdzdeeezgeffdZe dd dd d d d dddedededzdededzdededdededeeefdzdefdZe dd dd d d d dddededzdededzdededdededeeefdzdefdZe dd dd d d d dddededzdededzdededdededeeefdzdeeezgeffdZ d'dd dd d d d dddeezdzdedzdededzdededzdededdededeeefdzdeeeezgefzfd Zdedefd!Z d(ded"ed#eeefdzdee fd$Z d(dddd%dedee dzd"edzdedzd#eeefdzdef d&Z y))z)Convert functions and runnables to tools.N)Callable)AnyLiteralcastget_type_hintsoverload) BaseModelField create_model) Callbacks)Runnable) ArgsSchemaBaseTool)Tool)StructuredToolFTcontent description return_direct args_schema infer_schemaresponse_formatparse_docstringerror_on_invalid_docstringextrasrrrrr)rcontent_and_artifactrrrreturncyNrs Z/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/langchain_core/tools/convert.pytoolr"s14name_or_callablerunnablecyrr ) r$r%rrrrrrrrs r!r"r"sr#cyrr r$rrrrrrrrs r!r"r".sr#cyrr r(s r!r"r"=s14r#argsc  dtdtttzgtff fd t | dk7r d} t | |:|s d} t | t |ts d} t |  ||S|`t|r$t|dr |j|St |tr |Sd t|} t | d ttzdtf fd } | S) aConvert Python functions and `Runnables` to LangChain tools. Can be used as a decorator with or without arguments to create tools from functions. Functions can have any signature - the tool will automatically infer input schemas unless disabled. !!! note "Requirements" - Functions must have type hints for proper schema inference - When `infer_schema=False`, functions must be `(str) -> str` and have docstrings - When using with `Runnable`, a string name must be provided Args: name_or_callable: Optional name of the tool or the `Callable` to be converted to a tool. Overrides the function's name. Must be provided as a positional argument. runnable: Optional `Runnable` to convert to a tool. Must be provided as a positional argument. description: Optional description for the tool. Precedence for the tool description value is as follows: - This `description` argument (used even if docstring and/or `args_schema` are provided) - Tool function docstring (used even if `args_schema` is provided) - `args_schema` description (used only if `description` and docstring are not provided) *args: Extra positional arguments. Must be empty. return_direct: Whether to return directly from the tool rather than continuing the agent loop. args_schema: Optional argument schema for user to specify. infer_schema: Whether to infer the schema of the arguments from the function's signature. This also makes the resultant tool accept a dictionary input to its `run()` function. response_format: The tool response format. If `'content'`, then the output of the tool is interpreted as the contents of a `ToolMessage`. If `'content_and_artifact'`, then the output is expected to be a two-tuple corresponding to the `(content, artifact)` of a `ToolMessage`. parse_docstring: If `infer_schema` and `parse_docstring`, will attempt to parse parameter descriptions from Google Style function docstrings. error_on_invalid_docstring: If `parse_docstring` is provided, configure whether to raise `ValueError` on invalid Google Style docstrings. extras: Optional provider-specific extra fields for the tool. Used to pass configuration that doesn't fit into standard tool fields. Chat models should process known extras when constructing model payloads. !!! example For example, Anthropic-specific fields like `cache_control`, `defer_loading`, or `input_examples`. Raises: ValueError: If too many positional arguments are provided (e.g. violating the `*args` constraint). ValueError: If a `Runnable` is provided without a string name. When using `tool` with a `Runnable`, a `str` name must be provided as the `name_or_callable`. ValueError: If the first argument is not a string or callable with a `__name__` attribute. ValueError: If the function does not have a docstring and description is not provided and `infer_schema` is `False`. ValueError: If `parse_docstring` is `True` and the function has an invalid Google-style docstring and `error_on_invalid_docstring` is True. ValueError: If a `Runnable` is provided that does not have an object schema. Returns: The tool. Examples: ```python @tool def search_api(query: str) -> str: # Searches the API for the query. return @tool("search", return_direct=True) def search_api(query: str) -> str: # Searches the API for the query. return @tool(response_format="content_and_artifact") def search_api(query: str) -> tuple[str, dict]: return "partial json of results", {"full": "object of results"} ``` Parse Google-style docstrings: ```python @tool(parse_docstring=True) def foo(bar: str, baz: int) -> str: """The foo. Args: bar: The bar. baz: The baz. """ return bar foo.args_schema.model_json_schema() ``` ```python { "title": "foo", "description": "The foo.", "type": "object", "properties": { "bar": { "title": "Bar", "description": "The bar.", "type": "string", }, "baz": { "title": "Baz", "description": "The baz.", "type": "integer", }, }, "required": ["bar", "baz"], } ``` Note that parsing by default will raise `ValueError` if the docstring is considered invalid. A docstring is considered invalid if it contains arguments not in the function signature, or is unable to be parsed into a summary and `"Args:"` blocks. Examples below: ```python # No args section def invalid_docstring_1(bar: str, baz: int) -> str: """The foo.""" return bar # Improper whitespace between summary and args section def invalid_docstring_2(bar: str, baz: int) -> str: """The foo. Args: bar: The bar. baz: The baz. """ return bar # Documented args absent from function signature def invalid_docstring_3(bar: str, baz: int) -> str: """The foo. Args: banana: The bar. monkey: The baz. """ return bar ``` tool_namerc Ldttzdtf f d }|S)zCreate a decorator that takes a callable and returns a tool. Args: tool_name: The name that will be assigned to the tool. Returns: A function that takes a callable or Runnable and returns a tool. dec_funcrc <  }t|tr|jjj ddk7r d}t | d dt dzdtdtffd } d dt dzdtdtffd }|}|}j} xs t}n"tj|r|}d} }nd}|} } s tj||||  S|j d }t |t|d | S)Ntypeobjectz$Runnable must have an object schema. callbackskwargsrcHKj|d|id{S7wNr2ainvoker2r3r%s r!ainvoke_wrapperzRtool.._create_tool_factory.._tool_factory..ainvoke_wrappers'"*!1!1&; :R!SSSSs " "c,j|d|iSr5invoker8s r!invoke_wrapperzQtool.._create_tool_factory.._tool_factory..invoke_wrappers$??6K3KLLr#) namerrrrrrrrzUFunction must have a docstring if description not provided and infer_schema is False.z tool)r>funcrr coroutinerrr) isinstancer input_schemamodel_json_schemaget ValueErrorr rreprinspectiscoroutinefunctionr from_function__doc__r)r.tool_descriptionmsgr9r=r@r?schemar%rrrrrrrrr,s @r! _tool_factoryz9tool.._create_tool_factory.._tool_factory s{* (H-#((::<@@HHT@C$S/)37T(4/TBETT 37M(4/MBEMM , %,4,A,A#.#@$x. ,,X6$ $ ${6%33" 0"/ &!-$3$3/I!  'J!o%(k/+# / r#)rr r) r,rNrrrrrrrrs ` r!_create_tool_factoryz"tool.._create_tool_factorys)> Hx$7> H> > @r#rz3Too many arguments for tool decorator. A decorator z*Runnable without name for tool constructorz*Name must be a string for tool constructor__name__zZThe first argument must be a string or a callable with a __name__ for tool decorator. Got r?c|t|tr|jn |j}|}||S)z:Partial function that takes a callable and returns a tool.)rAr get_namerP)r?name_ tool_factoryrOs r!_partialztool.._partialzs2#-dH#= 4==+E2 D!!r#) strrr rlenrErAcallablehasattrrPr0)r$r%rrrrrrrrr*rLrUrOs ```````` @r!r"r"Ls4bLL 8h&'1 2LL\ 4yA~ Do >CS/ !*C0>CS/ !5#$45h??# $ %'2BJ*O C'(8(A(ABCST T & ,((89 9''+,<'=&> @ o "x(*"x" Or#cB|jj}d|dS)z1Generate a placeholder description of a runnable.zTakes .)rBrC)r%rBs r!_get_description_from_runnabler\s%((:: ##r#r> arg_typesc  | t|j}|jDcic]\}}||t df}}}t dt |fi|S#t$r}d|}t||d}~wwxYwcc}}w)zInfer args_schema for tool.NzTool input must be str or dict. If dict, dict arguments must be typed. Either annotate types (e.g., with TypedDict) or pass arg_types into `.as_tool` to specify. .ztype[BaseModel])r InputType TypeErroritemsr rr )r%r>r]erLkeykey_typefieldss r!'_get_schema_from_runnable_and_arg_typesrfs  (&x'9'9:I@I?P Qmc8cHeCj)) QF Q !<#?#? @@ (99:=  C.a '  (RsAA? A<&A77A<)r>rr]c<|rj||xs t}|xsj}jj }|j ddk(r#t |jj|Sddtdzdtdtffd }ddtdzdtdtffd }|2|j dd k(r|j d r j}nt|| }tj|||||S)aCConvert a Runnable into a BaseTool. Args: runnable: The runnable to convert. args_schema: The schema for the tool's input arguments. name: The name of the tool. description: The description of the tool. arg_types: The types of the arguments. Returns: The tool. ) input_typer0string)r>r?r@rNr2r3rcJKj|d|id{S7wNr2)configr6r8s r!r9z1convert_runnable_to_tool..ainvoke_wrappers(%%fk95M%NNNNs #!#c.j|d|iSrkr;r8s r!r=z0convert_runnable_to_tool..invoke_wrappersv{I.FGGr#r1 properties)r])r>r?r@rrr) with_typesr\rRrBrCrDrr<r7r rrfrrI)r%rr>rr]rMr9r=s` r!convert_runnable_to_toolrps2(&&+&>I!?!IK  &8$$&D  " " 4 4 6F zz&X%&&#   OT)9OCOTWOH)d"2HSHSH  JJv ( * JJ| $++ = di   ' '  !  r#)NNr)!rJrGcollections.abcrtypingrrrrrpydanticr r r langchain_core.callbacksr langchain_core.runnablesr langchain_core.tools.baserrlangchain_core.tools.simplerlangchain_core.tools.structuredrrVbooldictr"r\r0rfrpr r#r!r{s/$??33.-:,: #%)BK!'+$( 4t 4 4d" 4  4 >? 4 4!% 4 cNT ! 4x("#X-. 4  4 #%)BK!'+$(   t    d"  >?  !%  cNT !     #%)BK!'+$(  t   d"   >?  !%  cNT !     #%)BK!'+$( 4 4t 4 4 d" 4  4>? 4 4!% 4 cNT ! 4x("#X-. 4  4/3 $t#%)BK!'+$(tHnt+tot tt t  t d" tt>?tt!%t cNT !t(X-.899tn $X$#$)-AA ACI%A )_ A,+/9"(, 99i4'9 * 9 t 9 CI% 99r#