
    $jXC                       d Z ddlmZ ddlZddlZddlmZ ddlmZm	Z	 ddl
mZmZmZmZmZmZmZmZ ddlZddlmZ ddlmZmZmZ dd	lmZ dd
lmZ ddlZddlm Z  ddl!m"Z" ddl#m$Z$ ddl%m&Z& ddl'm(Z( ddl)m*Z*m+Z+m,Z, ddl-m.Z.m/Z/ ddl0m1Z1m2Z2 ddl3m4Z4 ddl5m6Z6m7Z7m8Z8  e4e9          Z:erddl;m<Z< ddl=m>Z>  ededef                   Z?e G d de                      Z@ edd           G d d                      ZA G d  d!e*          ZBedJd$            ZCeddddde6dddddddd%dKdB            ZCe	 dLdddddde6ddddddddCdMdF            ZC	 dLdddddde6ddddddddCdNdIZCdS )Oz'Standalone @tool decorator for FastMCP.    )annotationsN)Callable)	dataclassfield)TYPE_CHECKING	AnnotatedAnyLiteralProtocolTypeVaroverloadruntime_checkable)McpError)	ErrorDataIconToolAnnotations)Field)SkipJsonSchema)resolve_task_config)FastMCPDeprecationWarning)	AuthCheck)without_injected_parameters)
TaskConfig)Tool
ToolResultToolResultSerializerType)ParsedFunction_is_object_schema)call_sync_fn_in_threadpoolis_coroutine_function)
get_logger)NotSetNotSetTget_cached_typeadapter)Docket)	ExecutionF.)boundc                  &    e Zd ZU dZded<   d
dZd	S )DecoratedToolz,Protocol for functions decorated with @tool.ToolMeta__fastmcp__argsr	   kwargsreturnc                    d S N )selfr-   r.   s      c/home/rurouni/.hermes/hermes-agent/venv/lib/python3.11/site-packages/fastmcp/tools/function_tool.py__call__zDecoratedTool.__call__@   s          N)r-   r	   r.   r	   r/   r	   )__name__
__module____qualname____doc____annotations__r5   r2   r6   r4   r*   r*   :   s0         66======r6   r*   T)frozenkw_onlyc                     e Zd ZU dZ edd          Zded<   dZded	<   dZd
ed<   dZ	ded<   dZ
ded<   dZded<   dZded<   eZded<   dZded<   dZded<   dZded<   dZded<   dZded<   dZded<   dZd ed!<   dZd"ed#<   d$Zd%ed&<   dS )'r+   z6Metadata attached to functions by the @tool decorator.toolF)defaultinitzLiteral['tool']typeN
str | Nonenamestr | int | Noneversiontitledescriptionlist[Icon] | Noneiconsset[str] | Nonetagsdict[str, Any] | NotSetT | Noneoutput_schemaToolAnnotations | Noner   dict[str, Any] | Nonemetar	   appbool | TaskConfig | Nonetasklist[str] | Noneexclude_args
Any | None
serializerfloat | Nonetimeout"AuthCheck | list[AuthCheck] | NoneauthTboolenabled)r7   r8   r9   r:   r   rB   r;   rD   rF   rG   rH   rJ   rL   r"   rN   r   rQ   rR   rT   rV   rX   rZ   r\   r^   r2   r6   r4   r+   r+   C   sD        @@!E&u===D====D $G$$$$E"K""""#E#### D    5;M;;;;*.K...."&D&&&&COOOO%)D))))%)L))))!J!!!! G    /3D3333Gr6   r+   c                      e Zd ZU ded<   dZded<   edddddddddeddddddd7d%            Zd8d)Ze	d9d,            Z
d:d0Zddd1d;d6ZdS )<FunctionToolz"SkipJsonSchema[Callable[..., Any]]fnNz3Annotated[SkipJsonSchema[Any], Field(exclude=True)]return_type)metadatarD   rF   rG   rH   rJ   rL   r   rV   rN   rX   rQ   rT   rZ   r\   Callable[..., Any]rc   ToolMeta | NonerD   rC   rF   rE   rG   rH   rJ   rI   rL   rK   r   rO   rV   rU   rN   rM   rX   ToolResultSerializerType | NonerQ   rP   rT   rS   rZ   rY   r\   r[   r/   c                  t          d |||||||	|||||fD                       p|t          up|
du}||rt          d          |t          ||||||||	|||
|||          }|j        -t
          j        j        rt          j	        dt          d           |j        r-t
          j        j        rt          j	        dt          d           t          j        ||j        	          }|j        p|j        }|d
k    rt          d          |j        }|t#          d          }n,t%          |t&                    rt#          j        |          }n|}|                    ||           t%          |j        t.                    r|j        }n|j        }|6t%          |t0                    r!t3          |          st          d|           | di d|j        d|j        d|j        p|j        d|j        t;          |j                  ndd|j        d|j        |j        n|j        d|j         d|j!        d|d|j"        d|j#        ptI                      d|j        d|j%        d|d|j&        d|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.
        c              3  0   K   | ]}|d uo|t           uV  d S r1   )r"   ).0xs     r4   	<genexpr>z-FunctionTool.from_function.<locals>.<genexpr>   sC         1!6/     r6   Nz|Cannot pass both 'metadata' and individual parameters to from_function(). Use metadata alone or individual parameters alone.rD   rF   rG   rH   rJ   rL   rN   r   rQ   rT   rV   rX   rZ   r\   zThe `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.)rV   z<lambda>z,You must provide a name for lambda functions	forbidden)modezROutput schemas must represent object types due to MCP spec limitations. Received: ra   rb   rD   rF   rG   rH   rJ   
parametersrN   r   rL   rX   rQ   task_configrZ   r\   r2   )(anyr"   	TypeErrorr+   rX   fastmcpsettingsdeprecation_warningswarningswarnr   rV   r   from_functionrD   
ValueErrorrT   r   
isinstancer]   	from_boolvalidate_functionrN   r#   dictr   ra   rb   rF   strrG   rH   rJ   input_schemar   rL   setrQ   rZ   r\   )clsra   rc   rD   rF   rG   rH   rJ   rL   r   rV   rN   rX   rQ   rT   rZ   r\   individual_params_provided	parsed_fn	func_name
task_valuers   final_output_schemas                          r4   r{   zFunctionTool.from_function^   s   B         (" F*#($ 4'' 	#, $>E   '+')%  H" *w/?/T*Mg *      	W%5%J 	Me *    #0(BWXXX	M3Y^	
""KLLL ]
$+666KK
D)) 	%$.z::KK$K%%b)444 h,g66 	9"+"9"*"8*z:Mt/T/T*$%899  9!49 9  
 s 
 
 
||
!--
 0).
 .6-=-IC()))t	

 ..
 #/ !,,&
 ..
 !--
 .-
 !,,
 '#%%
  **
 
  $!
" $$#
$ %
 	
r6   	argumentsdict[str, Any]r   c                  K   t          | j                  }t          |          }| j        	 t	          j        | j                  5  t          |          r|                    |           d{V }n7t          |j        |           d{V }t          j
        |          r| d{V }|                     |           d{V }ddd           n# 1 swxY w Y   n# t          $ r\ t                              d| j         d| j         d           t!          t#          dd| j         d| j         d                    dw xY wt          |          r|                    |           d{V }n7t          |j        |           d{V }t          j
        |          r| d{V }|                     |           d{V }|                     |          S )	zRun the tool with arguments.NzTool 'z' timed out after z`s. Consider using task=True for long-running operations. See https://gofastmcp.com/servers/tasksi z' execution timed out after s)codemessage)r   ra   r$   rZ   anyio
fail_afterr    validate_pythonr   inspectisawaitable_materialize_generatorTimeoutErrorloggerwarningrD   r   r   convert_result)r3   r   
wrapper_fntype_adapterresults        r4   runzFunctionTool.run   s     099
-j99 <#%dl33 G G,Z88 	2'3'C'CI'N'N!N!N!N!N!N!N (B(8)( ( " " " " " " #.v66 2+1\\\\\\F $(#>#>v#F#FFFFFFFFG G G G G G G G G G G G G G G     ?TY ? ?$, ? ? ?  
 # _ _ _PTP\ _ _ _   
  %Z00 *+;;IFFFFFFFF9 0)          &v.. *#)\\\\\\F66v>>>>>>>>F""6***s1   C A>CC CC CC A&Er   r	   c                   K   t          j        |           rd | 2              d{V S t          j        |           rt          |           S | S )a  Consume generators/async generators into lists.

        Without this, async generators pass through as objects (repr string),
        and sync generators get consumed during text serialization but are
        exhausted by the time structured content is built.
        c                "   K   g | 3 d {V }|
6 S r1   r2   )ri   items     r4   
<listcomp>z7FunctionTool._materialize_generator.<locals>.<listcomp>*  s.      222222224D2222s   N)r   
isasyncgenisgeneratorlist)r   s    r4   r   z#FunctionTool._materialize_generator!  se       f%% 	32262222222222v&& 	 <<r6   docketr%   Nonec                    | j                                         sdS |                    | j        | j        g           dS )u  Register this tool with docket for background execution.

        Registers the raw function so Docket sees and resolves ALL
        dependencies — both FastMCP's (CurrentContext, Progress) and
        Docket-native ones (Retry, Timeout, ConcurrencyLimit).
        N)names)rs   supports_tasksregisterra   key)r3   r   s     r4   register_with_docketz!FunctionTool.register_with_docket/  sB     ..00 	Fz22222r6   )fn_keytask_keyr   r   r.   r&   c               Z   K   |p| j         }|r||d<     |j        |fi |di | d{V S )a  Schedule this tool for background execution via docket.

        FunctionTool splats the arguments dict since .fn expects **kwargs.

        Args:
            docket: The Docket instance
            arguments: Tool arguments
            fn_key: Function lookup key in Docket registry (defaults to self.key)
            task_key: Redis storage key for the result
            **kwargs: Additional kwargs passed to docket.add()
        r   Nr2   )r   add)r3   r   r   r   r   r.   
lookup_keys          r4   add_to_docketzFunctionTool.add_to_docket:  sa      ( 'tx
 	%$F5M5ZVZ
55f55BB	BBBBBBBBBr6   )"ra   rd   rc   re   rD   rC   rF   rE   rG   rC   rH   rC   rJ   rI   rL   rK   r   rO   rV   rU   rN   rM   rX   rf   rQ   rP   rT   rS   rZ   rY   r\   r[   r/   r`   )r   r   r/   r   )r   r	   r/   r	   )r   r%   r/   r   )r   r%   r   r   r   rC   r   rC   r.   r	   r/   r&   )r7   r8   r9   r;   rb   classmethodr"   r{   r   staticmethodr   r   r   r2   r6   r4   r`   r`   Z   s        ****GKKKKKK
 %)$( "&#' $.2)-9?6:&*)- $37'O
 O
 O
 O
 O
 [O
b/+ /+ /+ /+b    \	3 	3 	3 	3  "#C C C C C C C Cr6   r`   ra   r/   c                    d S r1   r2   )ra   s    r4   r?   r?   T  s    cr6   )rF   rG   rH   rJ   rL   rN   r   rQ   rT   rV   rX   rZ   r\   
name_or_fnr   rF   rE   rG   rC   rH   rJ   rI   rL   rK   rN   rM   r   'ToolAnnotations | dict[str, Any] | NonerQ   rP   rT   rS   rV   rU   rX   rW   rZ   rY   r\   r[   Callable[[F], F]c                   d S r1   r2   )r   rF   rG   rH   rJ   rL   rN   r   rQ   rT   rV   rX   rZ   r\   s                 r4   r?   r?   V  s	    " sr6   rl   r   rD   c                   d S r1   r2   )r   rD   rF   rG   rH   rJ   rL   rN   r   rQ   rT   rV   rX   rZ   r\   s                  r4   r?   r?   h  s	    $ sr6   str | Callable[..., Any] | Noner	   c                 	
 t          t                    rt          di t          | t                    rt	          d          d	
fdd	
fd
dfdt          j        |           r | |          S t          | t                    r|t	          d          | n$| |nt	          dt          |                      dfd}|S )zStandalone decorator to mark a function as an MCP tool.

    Returns the original function with metadata attached. Register with a server
    using mcp.add_tool().
    zsTo decorate a classmethod, use @classmethod above @tool. See https://gofastmcp.com/servers/tools#using-with-methodsra   rd   	tool_namerC   r/   r`   c                    t          |	t                    
          }t                              | |          S )Nrl   )rc   )r+   r   r`   r{   )ra   r   	tool_metar   r\   rH   rV   rJ   rQ   rN   rX   rL   rT   rZ   rG   rF   s      r4   create_toolztool.<locals>.create_tool  sd    #'#$T**%!
 
 
	  ))"y)AAAr6   r'   c                    t          |
	          }t          | d          r| j        n| }||_        | S )Nrl   __func__)r+   hasattrr   r,   )ra   r   rc   targetr   r\   rH   rV   rJ   rQ   rN   rX   rL   rT   rZ   rG   rF   s       r4   attach_metadataztool.<locals>.attach_metadata  sj    #'#%!
 
 
  !(J 7 7?R%	r6   c                    t           j        j        dk    r(t          j        dt
          d            | |          S  | |          S )Nobjectzdecorator_mode='object' is deprecated and will be removed in a future version. Decorators now return the original function with metadata attached.   rn   )rv   rw   decorator_modery   rz   r   )ra   r   r   r   s     r4   	decoratorztool.<locals>.decorator  s_    *h66MV)	    ;r9---r9---r6   Nz6Cannot specify name both as first argument and keywordzInvalid first argument: c                     |           S r1   r2   )ra   r   r   s    r4   wrapperztool.<locals>.wrapper  s    yY'''r6   r2   )ra   rd   r   rC   r/   r`   )ra   r'   r   rC   r/   r'   ra   r'   r/   r'   )	r}   r   r   r   ru   r   	isroutiner   rB   )r   rD   rF   rG   rH   rJ   rL   rN   r   rQ   rT   rV   rX   rZ   r\   r   r   r   r   r   s     ````````````` @@@@r4   r?   r?   }  s   . +t$$ 5%4444*k** 
I
 
 	

B B B B B B B B B B B B B B B B B B(                 *	. 	. 	. 	. 	. 	. 	. $$ 	GyT***	J	$	$ GTUUU						E4
3C3CEEFFF( ( ( ( ( ( ( Nr6   r   )r   r   rF   rE   rG   rC   rH   rC   rJ   rI   rL   rK   rN   rM   r   r   rQ   rP   rT   rS   rV   rU   rX   rW   rZ   rY   r\   r[   r/   r   r1   ) r   r   rD   rC   rF   rE   rG   rC   rH   rC   rJ   rI   rL   rK   rN   rM   r   r   rQ   rP   rT   rS   rV   rU   rX   rW   rZ   rY   r\   r[   r/   r   ) r   r   rD   rC   rF   rE   rG   rC   rH   rC   rJ   rI   rL   rK   rN   rM   r   r   rQ   rP   rT   rS   rV   rU   rX   rW   rZ   rY   r\   r[   r/   r	   )Dr:   
__future__r   r   ry   collections.abcr   dataclassesr   r   typingr   r   r	   r
   r   r   r   r   r   mcp.shared.exceptionsr   	mcp.typesr   r   r   pydanticr   pydantic.json_schemar   rv   fastmcp.decoratorsr   fastmcp.exceptionsr   !fastmcp.server.auth.authorizationr   fastmcp.server.dependenciesr   fastmcp.server.tasks.configr   fastmcp.tools.baser   r   r   fastmcp.tools.function_parsingr   r   fastmcp.utilities.async_utilsr   r    fastmcp.utilities.loggingr!   fastmcp.utilities.typesr"   r#   r$   r7   r   r   r%   docket.executionr&   r'   r*   r+   r`   r?   r2   r6   r4   <module>r      sx   - - " " " " " "   $ $ $ $ $ $ ( ( ( ( ( ( ( (	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	  * * * * * * 6 6 6 6 6 6 6 6 6 6       / / / / / /  2 2 2 2 2 2 8 8 8 8 8 8 7 7 7 7 7 7 C C C C C C 2 2 2 2 2 2         
 M L L L L L L L        1 0 0 0 0 0          
H		 +******GCxS)*** > > > > >H > > > $%%%       &%,wC wC wC wC wC4 wC wC wCt 
    
 	 !%"# 5;;?"&%)%)! /3     
" 
  $"# 5;;?"&%)%)! /3!     
* 37b  $"# 5;;?"&%)%)! /3!b b b b b b b br6   