
    piV,                    n   U d dl mZ d dl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mZ d dlmZ d dlmZmZ d dl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! ddl"m#Z# ddl$m%Z% ddl&m'Z(  ejR                  e*      Z+ee,ee(   f   Z-de.d<   ede-f   Z/ e
de/      Z0edeeee-f   f   Z1 e
de1      Z2 G d de      Z3 G d de      Z4 G d de	e#         Z5 G d de5e0         Z6 G d d e5e2         Z7ed+d!       Z8edddd"	 	 	 	 	 	 	 	 	 d,d#       Z8eddddd$	 	 	 	 	 	 	 	 	 d-d%       Z8	 d.ddddd$	 	 	 	 	 	 	 	 	 	 	 d/d&Z8ed0d'       Z9eddddd$	 	 	 	 	 	 	 	 	 	 	 d1d(       Z9eddddd$	 	 	 	 	 	 	 	 	 d2d)       Z9	 d.ddddd$	 	 	 	 	 	 	 	 	 	 	 d3d*Z9ee6e   e3f   Z:ee7e   e4f   Z;y)4    )annotationsN)ABCabstractmethod)	AnyUnionGenericTypeVarCallableIterable	Coroutinecastoverload)iscoroutinefunction)	TypeAliasoverride)	BaseModel   )_compat)is_dict)cached_property)TypeAdapter)BetaToolParamBetaToolUnionParam)	CallableT)InputSchema)Contentr   BetaFunctionToolResultType.	FunctionT)boundAsyncFunctionTc                  B    e Zd Zedd       Zedd       Zedd       Zy)BetaBuiltinFunctionToolc                     y N selfs    e/opt/services/ai/voice_agent/venv/lib/python3.12/site-packages/anthropic/lib/tools/_beta_functions.pyto_dictzBetaBuiltinFunctionTool.to_dict"       -0    c                     y r$   r%   r'   inputs     r(   callzBetaBuiltinFunctionTool.call%   s    ADr+   c                >    | j                         }d|v r|d   S |d   S Nmcp_server_namenamer)   r'   raws     r(   r3   zBetaBuiltinFunctionTool.name(   +    lln#())6{r+   Nreturnr   r.   objectr9   r   r9   str__name__
__module____qualname__r   r)   r/   propertyr3   r%   r+   r(   r"   r"   !   s0    0 0D D r+   r"   c                  B    e Zd Zedd       Zedd       Zedd       Zy)BetaAsyncBuiltinFunctionToolc                     y r$   r%   r&   s    r(   r)   z$BetaAsyncBuiltinFunctionTool.to_dict1   r*   r+   c                   K   y wr$   r%   r-   s     r(   r/   z!BetaAsyncBuiltinFunctionTool.call4   s	     GJs   c                >    | j                         }d|v r|d   S |d   S r1   r4   r5   s     r(   r3   z!BetaAsyncBuiltinFunctionTool.name7   r7   r+   Nr8   r:   r<   r>   r%   r+   r(   rD   rD   0   s0    0 0J J r+   rD   c                      e Zd ZU ded<   	 ded<   	 ded<   ded<   ddddd		 	 	 	 	 	 	 	 	 	 	 dd
Zedd       ZddZedd       Z	ddZ
ddZedd       Zy)BaseFunctionToolr   funcr=   r3   descriptionr   input_schemaNr3   rK   rL   defer_loadingc               p   t         j                  rt        d      || _        t	        j
                  |      | _        |xs |j                  | _        || _	        |xs | j                         | _        |.t        |t              r|j                         | _        y || _        y | j!                         | _        y )N2Tool functions are only supported with Pydantic v2)r   PYDANTIC_V1RuntimeErrorrJ   pydanticvalidate_call_func_with_validater?   r3   _defer_loading_get_description_from_docstringrK   
isinstancetypemodel_json_schemarL   _create_schema_from_function)r'   rJ   r3   rK   rL   rN   s         r(   __init__zBaseFunctionTool.__init__J   s     STT	#+#9#9$#? )DMM	+&P$*N*N*P#,-1=1O1O1Q!$0! $ A A CDr+   c                    | j                   S r$   rJ   r&   s    r(   __call__zBaseFunctionTool.__call__e   s    yyr+   c                    | j                   | j                  | j                  d}| j                  | j                  |d<   |S )Nr3   rK   rL   rN   )r3   rK   rL   rV   )r'   defns     r(   r)   zBaseFunctionTool.to_dicti   sE    II++ --

 *$($7$7D!r+   c                \    t        j                  | j                  j                  xs d      S )N )docstring_parserparserJ   __doc__r&   s    r(   _parsed_docstringz"BaseFunctionTool._parsed_docstrings   s"    %%dii&7&7&=2>>r+   c                    | j                   j                  rJ| j                   j                  }| j                   j                  r|d| j                   j                   z  }|S y)z*Extract description from parsed docstring.z

rd   )rh   short_descriptionlong_description)r'   rK   s     r(   rW   z0BaseFunctionTool._get_description_from_docstringw   sX    !!3300BBK%%66d&<&<&M&M%NOOr+   c                    ddl m} ddlm}m} ddlm}  G d d|      } || j                  | j                        }| j                  j                  |      S )	z:Create JSON schema from function signature using pydantic.r   )
CoreSchema)JsonSchemaValueGenerateJsonSchema)ArgumentsParameterc                  J     e Zd Zd fdZddZe	 	 	 	 	 	 d fd       Z xZS )OBaseFunctionTool._create_schema_from_function.<locals>.CustomGenerateJsonSchemac               >    t         |           || _        || _        y r$   )superr\   _funcrh   )r'   rJ   parsed_docstring	__class__s      r(   r\   zXBaseFunctionTool._create_schema_from_function.<locals>.CustomGenerateJsonSchema.__init__   s     "!
)9&r+   c                    | S r$   r%   )r'   _args_kwdss      r(   r_   zXBaseFunctionTool._create_schema_from_function.<locals>.CustomGenerateJsonSchema.__call__   s    r+   c                ^   t         |   ||      }|j                  d      dk7  r|S |j                  d      }|rt        |      s|S | j                  j
                  D ]L  }|j                  |j                        }|rt        |      s,|j                  s9d|vs>|j                  |d<   N |S )NrY   r;   
propertiesrK   )rt   kw_arguments_schemagetr   rh   paramsarg_namerK   )r'   	argumentsvar_kwargs_schemaschemar|   paramprop_schemarw   s          r(   r}   zcBaseFunctionTool._create_schema_from_function.<locals>.CustomGenerateJsonSchema.kw_arguments_schema   s     4Y@QR::f%1!M#ZZ5
!)<!M "33:: GE",.."@K&gk.B ((]+-M5:5F5FM2G r+   )rJ   zCallable[..., Any]rv   r   r9   None)ry   r   rz   r   r9   z'CustomGenerateJsonSchema')r   z'list[ArgumentsParameter]'r   zCoreSchema | Noner9   rn   )r?   r@   rA   r\   r_   r   r}   __classcell__)rw   s   @r(   CustomGenerateJsonSchemarr      s=    :
 5 $5 !	 r+   r   )rJ   rv   )schema_generator)pydantic_corerm   pydantic.json_schemarn   ro   pydantic_core.core_schemarp   rJ   rh   _adapterjson_schema)r'   rm   rn   ro   rp   r   r   s          r(   r[   z-BaseFunctionTool._create_schema_from_function   sN     	-L@ 	'9  	D 4UYUkUkl}}((:J(KKr+   c                ,    t        | j                        S r$   )r   rU   r&   s    r(   r   zBaseFunctionTool._adapter   s    43344r+   )rJ   r   r3   
str | NonerK   r   rL   $InputSchema | type[BaseModel] | NonerN   bool | Noner9   r   )r9   r   )r9   r   )r9   zdocstring_parser.Docstringr<   )r9   r   )r9   zTypeAdapter[Any])r?   r@   rA   __annotations__r\   rB   r_   r)   r   rh   rW   r[   r   r%   r+   r(   rI   rI   ?   s    
O,
I;  "&=A%)DD 	D
  D ;D #D 
D6   ? ?*LX 5 5r+   rI   c                      e Zd ZddZy)BetaFunctionToolc                D   t        | j                        rt        d      t        |      s!t	        dt        |      j                         	  | j                  di t        t        |      S # t        j                  $ r}t        d| j                         |d }~ww xY w)NzJCannot call a coroutine function synchronously. Use `@async_tool` instead. Input must be a dictionary, got Invalid arguments for function r%   r   rJ   rR   r   	TypeErrorrY   r?   rU   r   r   rS   ValidationError
ValueErrorr3   r'   r.   es      r(   r/   zBetaFunctionTool.call   s    tyy)kllu~>tE{?S?S>TUVV	S+4++?d3.>??'' 	S>tyykJKQRR	Ss   A. .BBBNr:   r?   r@   rA   r/   r%   r+   r(   r   r          
Sr+   r   c                      e Zd ZddZy)BetaAsyncFunctionToolc                `  K   t        | j                        st        d      t        |      s!t	        dt        |      j                         	  | j                  di t        t        |       d {   S 7 # t        j                  $ r}t        d| j                         |d }~ww xY ww)NzGCannot call a synchronous function asynchronously. Use `@tool` instead.r   r   r%   r   r   s      r(   r/   zBetaAsyncFunctionTool.call   s     "499-hiiu~>tE{?S?S>TUVV	S111EDe4DEEEE'' 	S>tyykJKQRR	Ss<   AB.#A: 3A84A: 7B.8A: :B+B&&B++B.Nr:   r   r%   r+   r(   r   r      r   r+   r   c                     y r$   r%   r^   s    r(   	beta_toolr      s    ?Br+   ra   c                    y r$   r%   )rJ   r3   rK   rL   s       r(   r   r      s     #&r+   rM   c                     y r$   r%   rM   s       r(   r   r      s     :=r+   c               z    t         j                  rt        d      | t        |       S dfd}|S )aF  Create a FunctionTool from a function with automatic schema inference.

    Can be used as a decorator with or without parentheses:

    @function_tool
    def my_func(x: int) -> str: ...

    @function_tool()
    def my_func(x: int) -> str: ...

    @function_tool(name="custom_name")
    def my_func(x: int) -> str: ...
    rP   rJ   r3   rK   rL   rN   c                $    t        |       S Nr   )r   rJ   rN   rK   rL   r3   s    r(   	decoratorzbeta_tool.<locals>.decorator  s    Dkdq
 	
r+   rJ   r   r9   BetaFunctionTool[FunctionT])r   rQ   rR   r   rJ   r3   rK   rL   rN   r   s    ```` r(   r   r      sK    * OPPDkdq
 	


 

 r+   c                     y r$   r%   r^   s    r(   beta_async_toolr     s    TWr+   c                    y r$   r%   r   s        r(   r   r     s     -0r+   c                     y r$   r%   rM   s       r(   r   r     s	     ILr+   c               z    t         j                  rt        d      | t        |       S dfd}|S )aU  Create an AsyncFunctionTool from a function with automatic schema inference.

    Can be used as a decorator with or without parentheses:

    @async_tool
    async def my_func(x: int) -> str: ...

    @async_tool()
    async def my_func(x: int) -> str: ...

    @async_tool(name="custom_name")
    async def my_func(x: int) -> str: ...
    rP   r   c                $    t        |       S r   )r   r   s    r(   r   z"beta_async_tool.<locals>.decoratorH  s    $#%'
 	
r+   rJ   r    r9   %BetaAsyncFunctionTool[AsyncFunctionT])r   rQ   rR   r   r   s    ```` r(   r   r   %  sN    * OPP$#%'
 	

 
 r+   r   )
rJ   r   r3   r   rK   r   rL   r   r9   r   )
r3   r   rK   r   rL   r   rN   r   r9   z2Callable[[FunctionT], BetaFunctionTool[FunctionT]]r$   )rJ   zFunctionT | Noner3   r   rK   r   rL   r   rN   r   r9   zPBetaFunctionTool[FunctionT] | Callable[[FunctionT], BetaFunctionTool[FunctionT]]r   )rJ   r    r3   r   rK   r   rL   r   rN   r   r9   r   )
r3   r   rK   r   rL   r   rN   r   r9   zACallable[[AsyncFunctionT], BetaAsyncFunctionTool[AsyncFunctionT]])rJ   zAsyncFunctionT | Noner3   r   rK   r   rL   r   rN   r   r9   ziBetaAsyncFunctionTool[AsyncFunctionT] | Callable[[AsyncFunctionT], BetaAsyncFunctionTool[AsyncFunctionT]])<
__future__r   loggingabcr   r   typingr   r   r   r	   r
   r   r   r   r   inspectr   typing_extensionsr   r   rS   re   r   rd   r   _utilsr   r   _modelsr   
types.betar   r   _utils._utilsr   types.tool_paramr   'types.beta.beta_tool_result_block_paramr   BetaContent	getLoggerr?   logr=   r   r   Functionr   AsyncFunctionr    r"   rD   rI   r   r   r   r   BetaRunnableToolBetaAsyncRunnableToolr%   r+   r(   <module>r      s\   "  # ^ ^ ^ ' 1      & " ; & + Mg!(-c8K3H.H(I I IC334Kx0	iS2L(LMMN)?c 3 o5wy) o5dS'	2 SS,^< S 
 B 
 B 
 "9=&
& & 	&
 7& !& 
& 
 "9=!%=
= = 7	=
 = 8= 
= "$ "9=!%$
$ $ 	$
 7$ $ V$N 
 W 
 W 
 "9=!%0
0 0 	0
 70 0 +0 
0 
 "9=!%L
L L 7	L
 L GL 
L #', "9=!%,
, , 	,
 7, , o,^ )#.0GGH 3C8:VVW r+   