g3fiDUdZddlmZddlZddlZddlZddlZddlZddlm Z m Z ddl m Z ddlm Z ddlmZmZmZmZmZmZmZmZmZddlZddlmZmZmZmZmZmZmZdd l m!Z!dd l"mZ#dd l"mZ$dd l"mZ%dd lm&Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:m;Z;ddlZ>m?Z?m@Z@mAZAmBZBer ddlCZCddl mDZDdZEdZFGddeGZHdHdZIdIdZJdd dJdZKdd  dKd!ZL dLd"ZMddd# dMd$ZNdNdOd%ZO dPd&ZPGd'd(ZQddddd) dQd*ZRGd+d,eSZTe=eUeVefzZWeXZYd-eZd.<Gd/d0e1eVeUze,zefZ[dRd1Z\ dSd2Z] dTd3Z^ dUd4Z_ dVd5Z`dWd6ZadWd7ZbdXd8ZcdYd9ZddZd:ZeGd;d<ZfGd=d>ZgGd?d@efZhd[dAZi d\ d]dBZjddC d^dDZk d\ddC d_dEZlGdFdGee Zmy)`z/Base classes and utilities for LangChain tools.) annotationsN)ABCabstractmethod)Callable) signature) TYPE_CHECKING AnnotatedAnyLiteralTypeVarcastget_args get_originget_type_hints) BaseModel ConfigDictFieldPydanticDeprecationWarningSkipValidationValidationErrorvalidate_arguments) FieldInfo)r)r)r)override)AsyncCallbackManagerCallbackManager Callbacks)ToolCall ToolMessageToolOutputMixin)RunnableConfigRunnableSerializable ensure_config patch_configrun_in_executor)set_config_context)coro_with_context)_parse_google_docstring_py_38_safe_origin) TypeBaseModel_create_subset_model get_fieldsis_basemodel_subclassis_pydantic_v1_subclassis_pydantic_v2_subclass)Sequence) run_manager callbacks)text image_urlimagejson search_resultcustom_tool_call_outputdocumentfileceZdZdZy)SchemaAnnotationErrorzGRaised when args_schema is missing or has an incorrect type annotation.N__name__ __module__ __qualname____doc__W/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/langchain_core/tools/base.pyr;r;VsQrBr;cXt|tjtjhvS)zCheck if a type is an Annotated type. Args: typ: The type to check. Returns: `True` if the type is an Annotated type, `False` otherwise. )rtypingr typing_extensions)typs rC_is_annotated_typerHZs% c?v//1B1L1LM MMrBct|rTt|}|ddD]A}t|tr|cSt|ts(|j s5|j cSy)aExtract description from an Annotated type. Checks for string annotations and `FieldInfo` objects with descriptions. Args: arg_type: The type to extract description from. Returns: The description string if found, None otherwise. N)rHr isinstancestrr description)arg_typeannotated_args annotations rC_get_annotation_descriptionrQfs_(#!(+(, .J*c*!!*i0Z5K5K!---  . rBT)include_injectedc&|jd}t|j}t|j Dcic]<\}\}}||vr0|dkDs|j dvr|st |js|||>c}}}Scc}}}w)aGet filtered arguments from a function's signature. Args: inferred_model: The Pydantic model inferred from the function. func: The function to extract arguments from. filter_args: Arguments to exclude from the result. include_injected: Whether to include injected arguments. Returns: Dictionary of filtered arguments with their schema definitions. propertiesr>clsself)model_json_schemar parameters enumerateitemsname_is_injected_arg_typerP) inferred_modelfunc filter_argsrRschema valid_keysikparams rC_get_filtered_argsre{s$ - - / =F4++J'z'7'7'9:   Az5 K  Uejj7 %:5;K;K%L 6!9   sAB Ferror_on_invalid_docstringcZtj|}t|t||S)aParse function and argument descriptions from a docstring. Assumes the function docstring follows Google Python style guide. Args: function: The function to parse the docstring from. annotations: Type annotations for the function parameters. error_on_invalid_docstring: Whether to raise an error on invalid docstring. Returns: A tuple containing the function description and argument descriptions. rf)inspectgetdocr'list)functionrrg docstrings rC _parse_python_function_docstringrns-x(I " [#= rBc<|D]}||vsd|d}t|y)a-Validate that docstring arguments match function annotations. Args: arg_descriptions: Arguments described in the docstring. annotations: Type annotations from the function signature. Raises: ValueError: If a docstring argument is not found in function signature. zArg z. in docstring not found in function signature.N) ValueError)arg_descriptionsr docstring_argmsgs rC,_validate_docstring_args_against_annotationsrts4*"  +'UVCS/ !"rBparse_docstringrgctj|d}|rt|||\}}ntj|xsd}i}|r t |||j D]\}}||vr t|x}s|||<||fS)aInfer argument descriptions from function docstring and annotations. Args: fn: The function to infer descriptions from. parse_docstring: Whether to parse the docstring for descriptions. error_on_invalid_docstring: Whether to raise error on invalid docstring. Returns: A tuple containing the function description and argument descriptions. T)include_extrasrf)rErrnrirjrtrZrQ) fnrvrgrrMrqargrNdescs rC_infer_arg_descriptionsr}s ''4@K(H  8R) % %nnR(.B 45E{S***,) X " " .x8 84 8$( S ! ) ( ((rBc\|dk(rtnt} t||S#t$rYywxYw)aCheck if a type annotation is a Pydantic model. Args: annotation: The type annotation to check. pydantic_version: The Pydantic version to check against ("v1" or "v2"). Returns: `True` if the annotation is a Pydantic model, `False` otherwise. v1F) BaseModelV1r issubclass TypeError)rPpydantic_versionbase_model_classs rC_is_pydantic_annotationrs8'7$&>{I*&677 s  ++ctd|jjD}td|jjD}|r|rd|d}t||xr| S)aaCheck if all Pydantic annotations in a function are from V1. Args: signature: The function signature to check. func: The function being checked. Returns: True if all Pydantic annotations are from V1, `False` otherwise. Raises: NotImplementedError: If the function contains mixed V1 and V2 annotations. c3JK|]}t|jdyw)rrNrrP.0 parameters rC z8_function_annotations_are_pydantic_v1..(  4 4tLL!#c3JK|]}t|jdyw)v2rNrrs rCrz8_function_annotations_are_pydantic_v1..rrz Function zv contains a mix of Pydantic v1 and v2 annotations. Only one version of Pydantic annotations per function is supported.)anyrXvaluesNotImplementedError)rr^any_v1_annotationsany_v2_annotationsrss rC%_function_annotations_are_pydantic_v1rs"--446"--4460vR R "#&&  8&8"88rBc0eZdZUdZdZded< dZded<y) _SchemaConfigzEConfiguration for Pydantic models generated from function signatures.forbidrLextraTboolarbitrary_types_allowedN)r=r>r?r@r__annotations__rrArBrCrrs OE35$(T(8rBr)r_rvrgrRc(tj|}t||rt|t}nIt j 5t jdtt|t}dddt|jxrd|jv}d} d} |jjD]:} | j| jk(rd} | j| j k(s9d} <j"} |r|} nt%|jj'}|r|dd vr|r|dgt%t(} nt%t(} |D]9}|rt+|j|j,s)| j/|;t1||| \}}g}t3| D].}| s|d k(r | s|d k(r|d k(r|| vs|j/|0t5|| t%|||S#1swYxYw)aZCreate a Pydantic schema from a function's signature. Args: model_name: Name to assign to the generated Pydantic schema. func: Function to generate the schema from. filter_args: Optional list of arguments to exclude from the schema. Defaults to `FILTERED_ARGS`. parse_docstring: Whether to parse the function's docstring for descriptions for each argument. error_on_invalid_docstring: if `parse_docstring` is provided, configure whether to raise `ValueError` on invalid Google Style docstrings. include_injected: Whether to include injected arguments in the schema. Defaults to `True`, since we want to include them in the schema when *validating* tool inputs. Returns: A Pydantic model with the same arguments as the function. )configignore)categoryN.FTr>rUrVruargskwargsv__duplicate_kwargs) descriptionsfn_description)rirrvalidate_arguments_v1rwarningscatch_warnings simplefilterrrrr?rXrkindVAR_POSITIONAL VAR_KEYWORDmodelrkkeys FILTERED_ARGSr\rPappendr}r+r*) model_namer^r_rvrgrRsig validatedin_classhas_args has_kwargsrdr] filter_args_existing_paramsexisting_paramrMrqvalid_propertiesfields rCcreate_schema_from_functionrs6   D !C,S$7)$}E  $ $ & G  ! !(5O P*4 FI  GD%%B#1B1B*BCHHJ&&( ::-- -H ZZ5,, ,J  __N" &*#..*=*=*?%@ q1_D+A.Em1DEL .L- 4N#(=~.99)##N3  4 %< '#=%!K! N+ +EVO ex/  ) )   $  # #E * +  %"  s G Gs -HHceZdZdZy) ToolExceptionaException thrown when a tool execution error occurs. This exception allows tools to signal errors without stopping the agent. The error is handled according to the tool's handle_tool_error setting, and the result is returned as an observation to the agent. Nr<rArBrCrrsrBrfrozenset[str] _EMPTY_SETceZdZUdZd0fd Zded< ded< eddZd ed < d Zd ed < d Z d ed< eddZ ded< dZ ded< dZ ded< d Z ded< d Zded< dZded< dZded< d0fd Zed Zed1d!Zed2d"Zed3d#Zej2d4d$Zed5d6fd% Ze d5 d7d&Ze d5 d7d'Z d8d(Ze d9d)Z!d9d*Z"d:d+Z# d;d,Z$ dd/Z&xZ'S)?BaseToolzBase class for all LangChain tools. This abstract class defines the interface that all LangChain tools must implement. Tools are components that can be called by agents to perform specific actions. c t|di||jjdd}|.|tk(r$d}|j }d|d|d|}t |yy)aValidate the tool class definition during subclass creation. Args: **kwargs: Additional keyword arguments passed to the parent class. Raises: SchemaAnnotationError: If `args_schema` has incorrect type annotation. args_schemaNzZ class ChildTool(BaseTool): ... args_schema: Type[BaseModel] = SchemaClass ...zTool definition for z must include valid type annotations for argument 'args_schema' to behave as expected. Expected annotation of 'Type[BaseModel]' but got 'z'. Expected class looks like: rA)super__init_subclass__rgetrr=r;)rUrargs_schema_typetypehint_mandater[rs __class__s rCrzBaseTool.__init_subclass__s !+F+..22=$G  ',< ,I  < FK 566rBct|jtr4|jri|jd|jiS|jS|j }g}t |j D]"\}}t|r|j|$t|j|||jS)zGet the schema for tool calls, excluding injected arguments. Returns: The schema that should be used for tool calls from language models. rM)r) rKrrrMget_input_schemaget_all_basemodel_annotationsrZr\rr*r[)rV full_schemafieldsr[type_s rCrzBaseTool.tool_call_schema@s d&& -&&!4#3#3 ## #++- 8EKKM $KD%(/ d# $$ II{F4;K;K  rBctSN)rrVs rC_injected_args_keyszBaseTool._injected_args_keysYs rBc|j5t|jtrt||S|jSt |j |jS)zThe tool's input schema. Args: config: The configuration for the tool. Returns: The input schema for the tool. )rrKrrrrr[_run)rVrrs rCrzBaseTool.get_input_schema`sR    '$**D1w/77## #*499dii@@rBc Ht||fi|\}}|j|fi|Sr)_prep_run_argsrunrVinputrr tool_inputs rCinvokezBaseTool.invokeps0,E6DVD Ftxx -f--rBcdKt||fi|\}}|j|fi|d{S7wr)rarunrs rCainvokezBaseTool.ainvokezs:,E6DVD FTYYz4V4444s '0.0c(|j}t|tr|t|tr d}t |t t t|j}t|tr|j||i|St|tr|j||i|Sd|}t||S|t|tr|St|trit|j!D]+\}}t#|t$s| d}t ||||<-|j|}|j'} nt|trit|j!D]+\}}t#|t$s| d}t ||||<-|j|}|j} nd|j}t)|t|} i} | D]b}||vrt+||| |<|| vs|dvs!| |} t-| dr| j/ n t+| dd } | sTt+||| |<d|j0D])}||vr ||| |<|d k(s| d}t ||| |<+| S|S) a$Parse and validate tool input using the args schema. Args: tool_input: The raw input to the tool. tool_call_id: The ID of the tool call, if available. Returns: The parsed and validated input. Raises: ValueError: If `string` input is provided with JSON schema `args_schema`. ValueError: If `InjectedToolCallId` is required but `tool_call_id` is not provided. TypeError: If `args_schema` is not a Pydantic `BaseModel` or dict. zQString tool inputs are not allowed when using tools with JSON schema args_schema.z.args_schema must be a Pydantic BaseModel, got ) injected_typezWhen tool includes an InjectedToolCallId argument, tool must always be invoked with a full model ToolCall of the form: {'args': {...}, 'name': '...', 'type': 'tool_call', 'tool_call_id': '...'})rr is_requiredrequiredT tool_call_id)rrKrLrrpnextiterr+rrrmodel_validater parse_objrrrZr\InjectedToolCallId model_dumprgetattrhasattrrr)rVrr input_argsrskey_rcvresult result_dict field_infovalidated_inputfi has_defaults rC _parse_inputzBaseTool._parse_inputs$%% j# &%j$/D%S/)DJ!7!?@j)4--tZ.@A    K8(($ );< K:,WC#C.(   !*d+!!*i09*EKKM 5DAq,Q>PQ'/!9 #-S/1(4 1  5$22:>$//1 J 49*EKKM 5DAq,Q>PQ'/!9 #-S/1(4 1  5$--j9$kkm ETEUEUDVW*#.. $J/J O  @ ?)0);OA&*_2D)D$AB#2}5NN,,!(Z!>> #-4VQ-?*! @$-- 6 ?)3AOA&.(#+5)o-)5OA& 6# "rBcy)zUse the tool. Add `run_manager: CallbackManagerForToolRun | None = None` to child implementations to enable tracing. Returns: The result of the tool execution. NrArVrrs rCrz BaseTool._runrBcK|jdrDt|jjjdr|dj |d<t d|jg|i|d{S7w)zUse the tool asynchronously. Add `run_manager: AsyncCallbackManagerForToolRun | None = None` to child implementations to enable tracing. Returns: The result of the tool execution. r0N)rrrrXget_syncr$rs rC_arunzBaseTool._arun sn ::m $499)=)H)H)L)L * %+=$9$B$B$DF= !$T499FtFvFFFFsA3A<5A:6A<cttt}|j|j|j M t |j }|jD]"\}}t|s|j|$ |jDcic] \}}||vs ||c}}S#t$rY4wxYwcc}}w)aFilter out injected tool arguments from the input dictionary. Injected arguments are those annotated with `InjectedToolArg` or its subclasses, or arguments in `FILTERED_ARGS` like `run_manager` and callbacks. Args: tool_input: The tool input dictionary to filter. Returns: A filtered dictionary with injected arguments removed. ) setrLrupdaterrrrZr\add Exception)rVr filtered_keysr field_name field_typercr s rC_filter_injected_argszBaseTool._filter_injected_argssC/  T556    ' ;DAH?H%H?H"H?%H<9H?;H<<H??K(I;; K(J44KKKc DKtj||j|jxs t |||j ||j } t|tr|j|nd}t|tr|nt||n|}| j|j|jd|f||| || d| d{}d}d}d}d} |j|| \}}t| |j!}t#|5}|j$j&t(j&ur |j*n |j&}t-|j.j1dr||d<t3|x}r| ||<|j&|i|}t5||d{}ddd|j6dk(r2dt9d }t|t:s t=|}n |\}}n}|r|jO|d{|tQ||| |j|}|jR|f||jd | d{|S77#1swYxYw#t<$rt=|}YwxYw#t>$r2}|j@s|}ntC||j@ }d }Yd}~d}~wtD$r2}|jFs|}ntI||jF }d }Yd}~d}~wtJtLf$r }|}Yd}~d}~wwxYw77ŭw) amRun the tool asynchronously. Args: tool_input: The input to the tool. verbose: Whether to log the tool's progress. start_color: The color to use when starting the tool. color: The color to use when ending the tool. callbacks: Callbacks to be called during tool execution. tags: Optional list of tags associated with the tool. metadata: Optional metadata associated with the tool. run_name: The name of the run. run_id: The id of the run. config: The configuration for the tool. tool_call_id: The id of the tool call. **kwargs: Keyword arguments to be passed to tool callbacks Returns: The output of the tool. Raises: ToolException: If an error occurs during tool execution. Nr(r)r,r-r0r.r/rr0r2r3)*rr4r1rrrrrKrr rLr5r[rMr$r#r6r%rrrrrrXrr7r&rr"r8rprrr:rrr;rr<r=r>r?) rVrrr@r*r1rrr%r&rrrrArBrCr0rrDrErFrIrJrGrH func_to_checkrKcororLrsrMrNs rCrz BaseTool.aruns?L099  NN LL )DM  II  MM *d+  & &z 2 *c* ':'F#J ;,::YYt/?/? @   &%     ?C+ %)%=%=j,%W "I{'+:O:O:QRL#L1 BW!%!5!5!GDIITZZ]+66::=I1r?r@rrrrrrr1rrrrrrrr model_configpropertyrrr functoolscached_propertyrrrrrrrrrr r$rr __classcell__)rs@rCrrs-B IL CH"4CK? M4 GT- tBKO?K%)F !("#( $L77$  0  A A)-.$.&. . ..)-5$5&5 5 55w$w4>w wr   GO@%$%4>% %T $")## ~"&*.##'(,#'~(~~ ~  ~  ~~(~~!~&~!~~ ~F $")## A"&*.##'(,#'AAA A  A  AA(AA!A&A!AA ArBrcNt|txr|jddk(S)zCheck if the input is a tool call dictionary. Args: x: The input to check. Returns: `True` if the input is a tool call, `False` otherwise. r" tool_call)rKrr)xs rC _is_tool_callrfds# a  ?155=K#??rBct|trd}|St|tr|}|St|r ||}|Sd|}t |)a/Handle validation errors based on the configured flag. Args: e: The validation error that occurred. flag: How to handle the error (`bool`, `str`, or `Callable`). Returns: The error message to return. Raises: ValueError: If the flag type is unexpected. zTool input validation errorz\Got unexpected type of `handle_validation_error`. Expected bool, str or callable. Received: )rKrrLcallablerprMr1rrss rCr:r:psk"$/ N D#  N $q' N **. 1 orBct|tr!|jr|jd}|Sd}|St|tr|}|St |r ||}|Sd|}t |)a1Handle tool execution errors based on the configured flag. Args: e: The tool exception that occurred. flag: How to handle the error (`bool`, `str`, or `Callable`). Returns: The error message to return. Raises: ValueError: If the flag type is unexpected. rzTool execution errorzVGot unexpected type of `handle_tool_error`. Expected bool, str or callable. Received: )rKrrrLrhrpris rCr;r;s"$ vv!&&) N,B N D#  N $q' N &&*V - orBc ft|}t|r-td|d}td|dj}nd}td|}|t d |j d|j d|j d|j d |j d d||d |fS) a Prepare arguments for tool execution. Args: value: The input value (`str`, `dict`, or `ToolCall`). config: The runnable configuration. **kwargs: Additional keyword arguments. Returns: A tuple of `(tool_input, run_kwargs)`. ridrNrXr1rrr%r&)r1rrr%r&rrrA)r"rfr r#rrpop)valuerrrrs rCrrs6 "FU#' E#:4#@ !%j%!8!@!E!E!G  ,.  jj-F#ZZ +ZZ +::h-%    rBcvt|ts||St|s t|}t |||||S)aFormat tool output as a `ToolMessage` if appropriate. Args: content: The main content of the tool output. artifact: Any artifact data from the tool. tool_call_id: The ID of the tool call. name: The name of the tool. status: The execution status. Returns: The formatted output, either as a `ToolMessage` or the original content. )rDrr[rE)rKr_is_message_content_type _stringifyr)rrDrr[rEs rCr>r>sF&'?+|/C #G ,W% !   rBcnt|txs$t|txrtd|DS)zCheck if object is valid message content format. Validates content for OpenAI or Anthropic format tool messages. Args: obj: The object to check. Returns: `True` if the object is valid message content, `False` otherwise. c32K|]}t|ywr)_is_message_content_block)rrMs rCrz+_is_message_content_type..s%Pq&?&B%Ps)rKrLrkallobjs rCrprps2 c3  3P#%PC%P"PrBcvt|tryt|tr|jddtvSy)zCheck if object is a valid message content block. Validates content blocks for OpenAI or Anthropic format. Args: obj: The object to check. Returns: `True` if the object is a valid content block, `False` otherwise. Tr"NF)rKrLrrTOOL_MESSAGE_BLOCK_TYPESrvs rCrtrts5#s#twwvt$(@@@ rBcf tj|dS#t$rt|cYSwxYw)zConvert content to string, preferring JSON format. Args: content: The content to stringify. Returns: String representation of the content. F) ensure_ascii)r5dumpsrrL)rs rCrqrqs1zz'66 7|s 00ct|tjr |j} t |S#t $rYywxYw)zGet type hints from a function, handling partial functions. Args: func: The function to get type hints from. Returns: `dict` of type hints, or `None` if extraction fails. N)rKr`partialr^rr)r^s rC_get_type_hintsr&s?$ ))*yyd## s 3 ??cht|}|sy|jD]\}}|tus|cSy)zFind the parameter name for `RunnableConfig` in a function. Args: func: The function to check. Returns: The parameter name for `RunnableConfig`, or `None` if not found. N)rrZr )r^ type_hintsr[rs rCr7r77sB!&J !'') e N "K rBceZdZdZy)InjectedToolArgzAnnotation for tool arguments that are injected at runtime. Tool arguments annotated with this class are not included in the tool schema sent to language models and are instead injected during execution. Nr<rArBrCrrIsrBrceZdZdZy)_DirectlyInjectedToolArgaAnnotation for tool arguments that are injected at runtime. Injected via direct type annotation, rather than annotated metadata. For example, `ToolRuntime` is a directly injected argument. Note the direct annotation rather than the verbose alternative: `Annotated[ToolRuntime, InjectedRuntime]` ```python from langchain_core.tools import tool, ToolRuntime @tool def foo(x: int, runtime: ToolRuntime) -> str: # use runtime.state, runtime.context, runtime.store, etc. ... ``` Nr<rArBrCrrQsrBrceZdZdZy)ra\Annotation for injecting the tool call ID. This annotation is used to mark a tool parameter that should receive the tool call ID at runtime. ```python from typing import Annotated from langchain_core.messages import ToolMessage from langchain_core.tools import tool, InjectedToolCallId @tool def foo( x: int, tool_call_id: Annotated[str, InjectedToolCallId] ) -> ToolMessage: """Return x.""" return ToolMessage( str(x), artifact=x, name="foo", tool_call_id=tool_call_id ) ``` Nr<rArBrCrrgsrBrct|txrt|txs3t |x}duxr"t|txrt|tS)awCheck if a type annotation indicates a directly injected argument. This is currently only used for `ToolRuntime`. Checks if either the annotation itself is a subclass of `_DirectlyInjectedToolArg` or the origin of the annotation is a subclass of `_DirectlyInjectedToolArg`. Ex: `ToolRuntime` or `ToolRuntime[ContextT, StateT]` would both return `True`. N)rKr"rrr)rorigins rC_is_directly_injected_arg_typersX 5$OJu6N$O e$ $T1 9 vt $ 9 v7 8 rBclt|ryttfdt|ddDS)a Check if a type annotation indicates an injected argument. Args: type_: The type annotation to check. injected_type: The specific injected type to check for. Returns: `True` if the type is an injected argument, `False` otherwise. NTc3vK|]0}t|xst|txr t|2ywr)rKr"r)rr{rs rCrz(_is_injected_arg_type..sD  3 & F sD ! Djm&D Fs69rJ)rrrr)rrs `rCr\r\sF *% 0'  E?12& rBdefault_to_boundc t|trt|}|jDcic]\}}|js|j|!}}}i}t j |jjD]1\}}|r ||vr||vr|j||}|j||<3t|dd} ntt|d}|f} t|tr t|s| D]} t| tr)t| r|jt| d 4 sOe V  sD !&=c&B! F&$',CF,K" ""1&5Q&v.M!(/}>NPR'S s#4hv6FuUVK 0A2F %7& FV& E" + 8&K%%'  Aq a2B CC cYb sG G 0Gcxsit|tr+|vr|Sr|j |jStS|St |x}r:t |x}r-t fd|D}tdt||S|S)a9Replace `TypeVar`s in a type annotation with concrete types. Args: type_: The type annotation to process. generic_map: Mapping of `TypeVar`s to concrete types. default_to_bound: Whether to use `TypeVar` bounds as defaults. Returns: The type with `TypeVar`s replaced. c3:K|]}t|yw)rN)r)rr{rrs rCrz%_replace_type_vars..s&  sKBR S S sr") rKr __bound__r rrr8r r()rrrrrnew_argss `` rCrrs #K%! K u% % &+oo&A5?? Js J U###(5/*A$*A   F.v6x@AA LrBc"eZdZdZeddZy) BaseToolkitzBase class for toolkits containing related tools. A toolkit is a collection of related tools that can be used together to accomplish a specific task or work with a particular system. cy)zmGet all tools in the toolkit. Returns: List of tools contained in this toolkit. NrArs rC get_toolszBaseToolkit.get_toolsrrBN)rRzlist[BaseTool])r=r>r?r@rrrArBrCrrs   rBr)rGz type[Any]rRr)rNr"rRrY) r]rVr^rr_z Sequence[str]rRrrRr)rlrrrrgrrRtuple[str, dict])rqrrrrRrS)rzrrvrrgrrRr)r)rPr rrLrRr)rzinspect.Signaturer^rrRr)rrLr^rr_zSequence[str] | NonervrrgrrRrrRrV)rer rRr)rMz#ValidationError | ValidationErrorV1r1zJLiteral[True] | str | Callable[[ValidationError | ValidationErrorV1], str]rRrL)rMrr1z;Literal[True] | str | Callable[[ToolException], str] | NonerRrL)rnrWrrUrr rRztuple[str | dict, dict]) rr rDr rrYr[rLrErLrRzToolOutputMixin | Any)rwr rRr)rr rRrL)r^rrRzdict[str, type] | None)r^rrRrY)rr rRrr)rtype | TypeVarrztype[InjectedToolArg] | NonerRr)rUzTypeBaseModel | AnyrrrRzdict[str, type | TypeVar])rrrzdict[TypeVar, type] | NonerrrRr)nr@ __future__rr`rir5rErabcrrcollections.abcrrrr r r r r rrrrFpydanticrrrrrrrpydantic.fieldsr pydantic.v1rr9rrlangchain_core.callbacksrrrlangchain_core.messages.toolrrrlangchain_core.runnablesr r!r"r#r$langchain_core.runnables.configr%langchain_core.runnables.utilsr&%langchain_core.utils.function_callingr'r(langchain_core.utils.pydanticr)r*r+r,r-r.uuidr/rryrr;rHrQrernrtr}rrrrrrrrLrT frozensetrrrrfr:r;rr>rprtrqrr7rrrrr\rrrrArBrCrs5" #$   &0<C& PO?<(,  RIR N4" #      <RW%)JN."")-" "*"', )))!% )  )D"9 9(09 9@99)-!',!`` `& `  ` !% ```FIT#s(^ + &[ N(S #C$J$93$>?S l @* U @ F @" " !"" "J       @  $ "$,6&JN *F :;?C C37CCP/3"  +   @  )S  rB