kKj4odZddlmZddlZddlZddlZddlZddlmZddl m Z m Z ddlm Z ddl mZddlmZmZmZmZmZmZmZmZmZmZddlZdd lmZdd lmZmZm Z dd l!m"Z"m#Z#dd l!m$Z%dd l&m'Z'ddl(Z(ddl)m*Z*m+Z+ddl,m-Z-m$Z$ddl.m/Z/m0Z0m1Z1ddl2m3Z3m4Z4ddl5m6Z6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?m@Z@mAZAe;eBZCer ddlDmEZEddlFmGZGGddeHZIe dd0dZJededef ZKeGd!d"eZLe d#d#$Gd%d&ZMd1d'ZNGd(d)e/ZOed2d*ZPeddddde?dddddddd#d+ d3d,ZPe d4dddddde?dddddddd#d- d5d.ZP d4dddddde?dddddddd#d- d6d/ZPy)7z'Standalone @tool decorator for FastMCP.) annotationsN)Callable) dataclassfield) lru_cache) MethodType) TYPE_CHECKING AnnotatedAnyLiteralProtocolTypeVarcastget_type_hintsoverloadruntime_checkable)McpError) ErrorDataIconToolAnnotations)Field TypeAdapter)ValidationError)SkipJsonSchema)get_fastmcp_metaresolve_task_config)FastMCPDeprecationWarningr)Tool ToolResultToolResultSerializerType)ParsedFunction_is_object_schema)call_sync_fn_in_threadpoolis_coroutine_function) AuthCheck) get_logger) TaskConfig)NotSetNotSetTget_cached_typeadapter)Docket) ExecutionceZdZdZy)_ToolBodyErroru4Marks a ``pydantic.ValidationError`` raised while executing a tool's body. Pydantic validates a tool's arguments *before* invoking the body, so a bare ``pydantic.ValidationError`` surfacing from the call adapter is unambiguously an argument-validation failure (a bad call). Errors a tool raises from its own body — e.g. constructing a model from upstream data — are a different class of problem (a server-side bug) that must not be reclassified as a bad call. We wrap the body so those are tagged and can be told apart. See #4128. N)__name__ __module__ __qualname____doc__l/Users/ahmed/devFolder/Ultron/claude-voice/.venv/lib/python3.12/site-packages/fastmcp/tools/function_tool.pyr.r.>sr4r.i)maxsizectrd fd }nd fd } td}tj}i}|j j D]H\}}||vr ||||<|jtjjus:|j||<Jd|vr |d|d<n5|jtjjur|j|d<||_ ||_ tdd|_tdd |_td |j"|_td |j$|_|S#t$ri}Y8wxYw) uWrap ``fn`` so a ``pydantic.ValidationError`` raised by its body is re-raised as ``_ToolBodyError``. The wrapper preserves ``fn``'s signature and annotations so the cached ``TypeAdapter`` validates arguments identically — only body execution is affected. Argument validation happens before the wrapper is called, so it keeps raising a bare ``pydantic.ValidationError``. returncbK |i|d{S7#t$r }t|d}~wwxYwwNPydanticValidationErrorr.argskwargsefns r5wrapperz"_wrap_body_errors..wrapperVs9 ,00000* ,$!+ ,s(/ / ,',/cF |i|S#t$r }t|d}~wwxYwr:r;r=s r5rBz"_wrap_body_errors..wrapper]s0 ,4*6*** ,$!+ ,s  Tinclude_extrasr/rBr2Nr0r1r>r r?r r8r )r$r Exceptioninspect signature parametersitems annotation Parameteremptyreturn_annotation Signature __signature____annotations__getattrr/r2r0r1)rArBresolved_hintssigr param_nameparams` r5_wrap_body_errorsrXJsYR  , ,'4@   B C"$K ^^113 E  '&4Z&@K #   W%6%6%<%< <&+&6&6K # 4 >! .x 8 H  g&7&7&=&= = # 5 5 HG)Gr:y9Gb)T2GO \73E3EFG"2~w7K7KLG N) s E E! E!F.)boundc$eZdZUdZded<ddZy) DecoratedToolz,Protocol for functions decorated with @tool.ToolMeta __fastmcp__cyr:r3)selfr>r?s r5__call__zDecoratedTool.__call__s#r4NrF)r/r0r1r2rRrar3r4r5r\r\s6=r4r\T)frozenkw_onlyceZdZUdZeddZded<dZded <dZd ed <dZ ded <dZ ded <dZ ded<dZ ded<e Zded<dZded<dZded<dZded<dZded<dZded<dZded<dZd ed!<dZd"ed#<d$Zd%ed&<d$Zd%ed'<y)(r]z6Metadata attached to functions by the @tool decorator.toolF)defaultinitzLiteral['tool']typeN str | Nonenamestr | int | Noneversiontitle descriptionlist[Icon] | Noneiconsset[str] | Nonetagsdict[str, Any] | NotSetT | None output_schemaToolAnnotations | Nonerdict[str, Any] | Nonemetar appbool | TaskConfig | Nonetasklist[str] | None exclude_args Any | None serializer float | Nonetimeout"AuthCheck | list[AuthCheck] | NoneauthTboolenabled run_in_thread)r/r0r1r2rrhrRrjrlrmrnrprrr(rtrrwrxrzr|r~rrrrr3r4r5r]r]s@!&u=D/=D* $G $E:"K"#E # D/ 5;M2;*.K'."&D &CO%)D ")%)L")!J ! G\ /3D ,3GTM4r4r]c| t|dS#t$r|}t|tjr'|j }t|tjr' t|d}n#t$ricYcYSwxYwt j|jDcic] }||vr|||ncc}wc}cYSwxYw)aoResolve a callable's parameter type hints, tolerating partials. ``get_type_hints`` rejects ``functools.partial`` objects (and other non-function callables), which the synchronous TypeAdapter path handles natively. For those, resolve hints against the underlying function and keep only the parameters that remain in the partially-bound signature. TrD) r TypeError isinstance functoolspartialfuncrHrIrJ)rAtargetresolvedrjs r5_resolve_param_hintsrs b66   !2!23[[F!2!23 %fTBH I  ))"-88 8x (4. 8    s@ A B; A*)B;* A:5B;9A::$B;B0/ B;:B;ceZdZUded<dZded<dZded<edddddddddeddddddd  dd Zdd Z dd Z e dd Z ddZ ddd ddZddZy) FunctionToolz"SkipJsonSchema[Callable[..., Any]]rANz3Annotated[SkipJsonSchema[Any], Field(exclude=True)] return_typeTuAnnotated[bool, Field(description="Applies to sync tool functions only. When True (default), sync functions are dispatched to a worker thread so they don't block the event loop. Set to False to run the sync function inline on the event loop thread — useful for libraries with thread affinity (e.g. Windows COM, tkinter). Ignored for async functions, which always run on the event loop. Cannot be combined with `timeout` on a sync function: inline calls have no cancellation checkpoints, so the timeout would be a silent no-op.")]r)metadatarjrlrmrnrprrrr|rtr~rwrzrrrctd||||||| | || |||f Dxs| tuxs| du}| |r td||st|}t |t r|}|t ||||||| | | || | |||dn|}|j 6tjjrtjdtd|jr6tjjrtjd tdtj||j }|j xs |j }|d k(r t#d |j$;|j&s/t)|s$t+j,|st#d |d|j.}| t1d}n(t |t2rt1j4|}n|}|j7||t |j8t:r |j8}n |j8}|)t |t<rt?|st#d||d#id|j@d|jBd|j xs |j d|jDtG|jDndd|jHd|jJ |jJn |jJd|jLd|jNd|d|jPd|jRxs tUd|j d|jVd|d |j$d!|jXd"|j&S)$a{Create a FunctionTool from a function. Args: fn: The function to wrap metadata: ToolMeta object with all configuration. If provided, individual parameters must not be passed. name, title, etc.: Individual parameters for backwards compatibility. Cannot be used together with metadata parameter. c38K|]}|duxr|tuywr:)r().0xs r5 z-FunctionTool.from_function..s,A 1!6/1sNz|Cannot pass both 'metadata' and individual parameters to from_function(). Use metadata alone or individual parameters alone.Trjrlrmrnrprrrtrrwrzr|r~rrrzThe `serializer` parameter is deprecated. Return ToolResult from your tools for full control over serialization. See https://gofastmcp.com/servers/tools#custom-serialization for migration examples. stacklevelzThe `exclude_args` parameter is deprecated as of FastMCP 2.14. Use dependency injection with `Depends()` instead for better lifecycle management. See https://gofastmcp.com/servers/dependency-injection#using-depends for examples.)r|zz,You must provide a name for lambda functionszTool z: timeout cannot be enforced when run_in_thread=False on a sync function. Inline execution has no cancellation checkpoints, so the timeout would be a no-op. Either drop the timeout or remove run_in_thread=False and accept worker-thread dispatch. forbidden)modezROutput schemas must represent object types due to MCP spec limitations. Received: rArrjrlrmrnrprJrtrrrr~rw task_configrrrr3)-anyr(rrrr]r~fastmcpsettingsdeprecation_warningswarningswarnrr|r! from_functionrj ValueErrorrrr$rHisasyncgenfunctionrzr'r from_boolvalidate_functionrtr)dictr"rArrlstrrmrnrp input_schemarrrsetrwr)clsrArrjrlrmrnrprrrr|rtr~rwrzrrrindividual_params_providedfmeta parsed_fn func_name task_valuerfinal_output_schemas r5rzFunctionTool.from_functionsD !  ($F*% (&4') #.  $>E   $>$R(E%*   '+')%&3&;dH$    *w/?/?/T/T MMg*    W%5%5%J%J MMe*  #00(BWBWX MM3Y^^  "KL L    (**)"-..r2 }%11 ]]  $+6K  D )$..z:K$K%%b)4 h,,g 6"+"9"9 "*"8"8   *z:Mt/T$%89 !!4 79  || !-- 0).. .6-=-=-IC(()t  ..  ##/!,,&& .. !-- . !,, '#%  **  $! "$$# $% &#00'  r4c LKddlm}||j|j}t |}t |}t |} |jE tj|j5|j|||d{}dddn|j|||d{}|j1S79#1swY8xYw#t$rctjd|jd|jdtt!dd|jd |jd  dwxYw7#t"$r*}t%t'|t(j* |d}~wt,$r"}|j.} | J| | j.d}~wwxYww) zRun the tool with arguments.rwithout_injected_parametersrNzTool 'z' timed out after z`s. Consider using task=True for long-running operations. See https://gofastmcp.com/servers/tasksiz' execution timed out after s)codemessage log_level)fastmcp.server.dependenciesrrArrXr*r$ranyio fail_after_execute TimeoutErrorloggerwarningrjrrr<rrloggingWARNINGr. __cause__convert_result) r` argumentsr wrapper_fnexec_fn type_adapter exec_is_asyncresultr@originals r5runzFunctionTool.runsK0 GG4#5#5 $J/-g6 -j9 " 3||' ))$,,7'+}}(-("8" $}}\=)TT ""6**A"87$  NN  +=dll^LBC #!!'&,TYYK7STXT`T`Saab$c    U& L "#a&GOOD! K 3{{H' '' 2 2 2  3sAF$ EC5C C CCE0E1E5F$CC CA,EE F!%E33 F!?FF!!F$cXK|r|j|}n<|jrt|j|d{}n|j|} tj|r |d{}|j |d{S7O77#t $r }t|d}~wwxYww)aAValidate arguments and execute the tool body. Argument validation runs first and raises a bare ``pydantic.ValidationError`` on bad input. Body execution (awaiting the result and materializing generators) is wrapped so any pydantic error it raises is tagged as ``_ToolBodyError``. N)validate_pythonrr#rH isawaitable_materialize_generatorr<r.)r`rrrrr@s r5rzFunctionTool._executes !11) - + P&c!fHaO  Ps1B  B<%B77B<)$rACallable[..., Any]rzToolMeta | Nonerjrirlrkrmrirnrirprorrrqrrur|r{rtrsr~zToolResultSerializerType | Nonerwrvrzryrrrrrz bool | Noner8r)rdict[str, Any]r8r)rzTypeAdapter[Any]rrrrr8r )rr r8r )rr+r8None) rr+rrrrirrir?r r8r,)rrr8r)r/r0r1rRrr classmethodr(rrr staticmethodrrrrr3r4r5rrs**GKKDK   %)$( "&#' $.2)-9?6:&*)- $37%))l l " l  l "l l  l !l l ,l 'l 7l 4l $!l "'#l $%l &1'l (#)l * +l l \1+f$(&$($(" $( $(L   3 "# CC"C  C  CC C2%r4rcyr:r3)rAs r5rere4sr4)rlrmrnrprrrtrrwrzr|r~rrrcyr:r3) name_or_fnrlrmrnrprrrtrrwrzr|r~rrrs r5rere6s$r4rcyr:r3)rrjrlrmrnrprrrtrrwrzr|r~rrrs r5rereIs&r4c ttr tdit|tr t dd     fd d     fd d fd t j |r ||St|tr| t d|n||nt dt|d fd }|S) u*Standalone decorator to mark a function as an MCP tool. Returns the original function with metadata attached. Register with a server using mcp.add_tool(). Args: run_in_thread: Applies to sync tool functions only. When True (default), the sync function is dispatched to a worker thread so it does not block the event loop. Set to False to run the function inline on the event loop thread — useful for libraries with thread affinity (e.g. Windows COM via `uiautomation`/`comtypes`/`pywin32`, `tkinter`, some GPU/driver bindings). Ignored for async functions. Cannot be combined with `timeout` on a sync function: inline calls have no cancellation checkpoints, so the timeout would be a silent no-op. zsTo decorate a classmethod, use @classmethod above @tool. See https://gofastmcp.com/servers/tools#using-with-methodscxt| t   }tj||S)Nr)r)r]rrr)rA tool_name tool_metarrrnr|rprwrtrr~rrrzrrmrls r5 create_toolztool..create_toolsW#'#$T*%!' "))"y)AAr4ct|    }t|ttzr |jn|}|t t |_|S)Nr)r]rrr__func__rr r^)rArrrrrrnr|rprwrtrr~rrrzrrmrls r5attach_metadataztool..attach_metadatasi#'#%!' "!+2|j/H Ir(0S&% r4ctjjdk(r%tjdt d||S||S)Nobjectzdecorator_mode='object' is deprecated and will be removed in a future version. Decorators now return the original function with metadata attached.r)rrdecorator_moderrr)rArrrs r5 decoratorztool..decoratorsK    * *h 6 MMV)   r9- -r9--r4z6Cannot specify name both as first argument and keywordzInvalid first argument: c|Sr:r3)rArrs r5rBztool..wrappersY''r4r3)rArrrir8r)rArYrrir8rYrArYr8rY) rrrrrrH isroutinerrh)rrjrlrmrnrprrrtrrwrzr|r~rrrrBrrrrs `````````````` @@@@r5rere_sD+t$%4 4 *k* I  BBB*, .$T** J $  TU U   24 3C2DEFF( Nr4)rArr8r)rArr8rr) rrrlrkrmrirnrirprorrrqrtrsr'ToolAnnotations | dict[str, Any] | Nonerwrvrzryr|r{r~r}rrrrrrr8Callable[[F], F]r:)"rrrjrirlrkrmrirnrirprorrrqrtrsrrrwrvrzryr|r{r~r}rrrrrrr8r)"rzstr | Callable[..., Any] | Nonerjrirlrkrmrirnrirprorrrqrtrsrrrwrvrzryr|r{r~r}rrrrrrr8r )Qr2 __future__rrrHrrcollections.abcr dataclassesrrrtypesrtypingr r r r r rrrrrrmcp.shared.exceptionsr mcp.typesrrrpydanticrrrr<pydantic.json_schemarrfastmcp.decoratorsrrfastmcp.exceptionsrfastmcp.tools.baserrr fastmcp.tools.function_parsingr!r"fastmcp.utilities.async_utilsr#r$fastmcp.utilities.authorizationr%fastmcp.utilities.loggingr&fastmcp.utilities.tasksr'fastmcp.utilities.typesr(r)r*r/rrr+docket.executionr,rGr.rXrYr\r]rrrer3r4r5rs-"$(    *66'?/DI M60. H * Y  444n CxS)*>H>> $%&. 2r4rj    !%"# 5;;?"&%)%)! /3!       39  ## - !"# $  $"# 5;;?"&%)%)! /3#        39  ## -!"#$% ,37o $"# 5;;?"&%)%)! /3#o/o o o  o  o o o3o9o o #o#ooo -!o"#o$ %or4