܎jk^ ,UddlmZddlZddlZddlmZmZddlmZm Z m Z m Z m Z m Z mZmZmZddlmZmZmZmZddlmZddlmZmZmZddlZddlZddlZddlmZd d l m!Z!d d l"m#Z#d d l!m$Z$d d l%m&Z&d dl'm(Z(m)Z)m*Z*d dl+m,Z,d dl-m.Z.d dl/m0Z1ej2e3Z4e e5e e1fZ6de7d<Gdde8Z9e de6fZ:e de:Z;e deeee6ffZ<e de<Z=GddeZ>GddeZ?Gdde e,Z@Gd d!e@e;ZAGd"d#e@e=ZBdNd(ZCdNd)ZDdOd,ZEedPd/ZFedddddddddd0 dQd@ZFedddddddddd0 dRdBZF dSdddddddddd0 dTdEZFedUdGZGedddddddddd0 dVdHZGedddddddddd0 dWdJZG dSdddddddddd0 dXdMZGe eAee>fZHe eBee?fZIdS)Y) annotationsN)ABCabstractmethod) AnyUnionGenericTypeVarCallableIterable Coroutinecastoverload) isawaitableisasyncgenfunctioniscoroutinefunctionisgeneratorfunction) Awaitable)Literal TypeAliasoverride) BaseModel)_compat)is_dict)cached_property) TypeAdapter) BetaToolParamBetaToolUnionParamBetaCacheControlEphemeralParam) CallableT) InputSchema)ContentrBetaFunctionToolResultTypec0eZdZUdZded<dfd ZxZS) ToolErroraError that can be raised from a tool to return structured content with ``is_error: True``. When the tool runner catches this error, it will use the :attr:`content` property as the tool result instead of ``repr(exc)``. Example:: raise ToolError( [ {"type": "text", "text": "Error details here"}, {"type": "image", "source": {"type": "base64", "data": "...", "media_type": "image/png"}}, ] ) r#contentreturnNonect|tr|}ng}|D]i}|d}|#|t|<|d|dddj|rd|nd}t |||_dS)Ntext[typeunknown] z Tool error) isinstancestrgetappendjoinsuper__init__r&)selfr&messagepartsblockr* __class__s QC:\Projects\DSCons\.venv\Lib\site-packages\anthropic\lib\tools\_beta_functions.pyr6zToolError.__init__0s gs # # AGG!E  F Fyy((#LLT++++LL!DUYYvy%A%A!D!D!DEEEE).@chhuoooLG !!! )r&r#r'r()__name__ __module__ __qualname____doc____annotations__r6 __classcell__r;s@r<r%r%sW  ('''          r=r%. FunctionT)boundAsyncFunctionTcVeZdZed dZed dZed d Zd S)BetaBuiltinFunctionToolr'rcdSNr7s r<to_dictzBetaBuiltinFunctionTool.to_dictH-0Sr=inputobjectr#cdSrKrLr7rPs r<callzBetaBuiltinFunctionTool.callKsADr=r1cR|}d|vr|dS|dSNmcp_server_namenamerNr7raws r<rXzBetaBuiltinFunctionTool.nameN0llnn  # #() )6{r=Nr'rrPrQr'r#r'r1r>r?r@rrNrTpropertyrXrLr=r<rIrIGs^000^0DDD^D Xr=rIcVeZdZed dZed dZed d Zd S)BetaAsyncBuiltinFunctionToolr'rcdSrKrLrMs r<rNz$BetaAsyncBuiltinFunctionTool.to_dictWrOr=rPrQr#c KdSrKrLrSs r<rTz!BetaAsyncBuiltinFunctionTool.callZs GJsr=r1cR|}d|vr|dS|dSrVrYrZs r<rXz!BetaAsyncBuiltinFunctionTool.name]r\r=Nr]r^r_r`rLr=r<rcrcVs^000^0JJJ^J Xr=rcc eZdZUded< ded< ded<ded<dZd ed < dZd ed < dddddddddd d&dZed'dZd(dZ e d)d!Z d*d"Z d+d#Z e d,d%ZdS)-BaseFunctionToolr funcr1rX descriptionr! input_schemaNz+Callable[[], None | Awaitable[None]] | Noneclosez object | None_context_manager rXrjrk defer_loading cache_controlallowed_callerseager_input_streaminginput_examplesstrict str | None$InputSchema | type[BaseModel] | Nonero bool | Nonerp%BetaCacheControlEphemeralParam | Nonerqolist[Literal['direct', 'code_execution_20250825', 'code_execution_20260120', 'code_execution_20260521']] | Nonerrrs"Iterable[dict[str, object]] | Nonertr'r(c tjrtd||_t j||_|p|j|_||_ ||_ ||_ ||_ | |_ | |_|p||_|9t#|t$r||_dS||_dS||_dS)N2Tool functions are only supported with Pydantic v2)r PYDANTIC_V1 RuntimeErrorripydantic validate_call_func_with_validater>rX_defer_loading_cache_control_allowed_callers_eager_input_streaming_input_examples_strict_get_description_from_docstringrjr0r,model_json_schemark_create_schema_from_function) r7rirXrjrkrorprqrrrsrts r<r6zBaseFunctionTool.__init__s"   USTT T #+#9$#?#? )DM ++ /&;#- &P$*N*N*P*P  #,-- 11=1O1O1Q1Q!!!$0!!! $ A A C CD   r=c|jSrKrirMs r<__call__zBaseFunctionTool.__call__s yr=rc|j|j|jd}|j |j|d<|j |j|d<|j |j|d<|j |j|d<|j |j|d<|j |j|d<|S)N)rXrjrkrorprqrrrsrt) rXrjrkrrrrrr)r7defns r<rNzBaseFunctionTool.to_dictsI+ -     *$($7D !   *$($7D !  ,&*&;D" #  & 2,0,GD( )   +%)%9D! " < #!\DN r=docstring_parser.DocstringcBtj|jjpdS)N)docstring_parserparserirArMs r<_parsed_docstringz"BaseFunctionTool._parsed_docstrings%di&7&=2>>>r=cv|jjr,|jj}|jjr|d|jjz }|SdS)z*Extract description from parsed docstring.z r)rshort_descriptionlong_description)r7rjs r<rz0BaseFunctionTool._get_description_from_docstringsN  ! 3 0BK%6 POd&<&MOOO  rr=cddlm}ddlm}m}ddlm}Gdd|}||j|j}|j |S) z:Create JSON schema from function signature using pydantic.r) CoreSchema)JsonSchemaValueGenerateJsonSchema)ArgumentsParametercDeZdZdfd Zdd Zedfd ZxZS)OBaseFunctionTool._create_schema_from_function..CustomGenerateJsonSchemariCallable[..., Any]parsed_docstringrr'r(cdt||_||_dSrK)r5r6_funcr)r7rirr;s r<r6zXBaseFunctionTool._create_schema_from_function..CustomGenerateJsonSchema.__init__s.  """! )9&&&r=_args_kwds'CustomGenerateJsonSchema'c|SrKrL)r7rrs r<rzXBaseFunctionTool._create_schema_from_function..CustomGenerateJsonSchema.__call__s r= arguments'list[ArgumentsParameter]'var_kwargs_schemaCoreSchema | Nonercrt||}|ddkr|S|d}|rt|s|S|jjD]C}||j}|rt|s.|jrd|vr |j|d<D|S)Nr,rQ propertiesrj)r5kw_arguments_schemar2rrparamsarg_namerj)r7rrschemarparam prop_schemar;s r<rzcBaseFunctionTool._create_schema_from_function..CustomGenerateJsonSchema.kw_arguments_schemas 44Y@QRR::f%%11!M#ZZ 55 !")<)<"!M"3:GGE",.."@"@K&!gk.B.B! (G]+-M-M5:5F M2 r=)rirrrr'r()rrrrr'r)rrrrr'r)r>r?r@r6rrrrCrDs@r<CustomGenerateJsonSchemars{ : : : : : :          X     r=r)rir)schema_generator) pydantic_corerpydantic.json_schemarrpydantic_core.core_schemarrir_adapter json_schema)r7rrrrrrs r<rz-BaseFunctionTool._create_schema_from_functions -,,,,,LLLLLLLL@@@@@@     '9   D43UYUklll}((:J(KKKr=TypeAdapter[Any]c*t|jSrK)rrrMs r<rzBaseFunctionTool._adapters43444r=)rir rXrurjrurkrvrorwrprxrqryrrrwrsrzrtrwr'r()r'r )r'r)r'rr_)r'r!)r'r)r>r?r@rBrlrmr6rarrNrrrrrrLr=r<rhrhesZOOO, III;9=E====$'+**** "&=A%)?C-1=A"&D&D&D&D&D&DPX(???_?*L*L*L*LX555_555r=rhceZdZddZdS)BetaFunctionToolrPrQr'r#cNt|jrtdt|s$t dt |j |jditt|S#tj $r}td|j |d}~wwxYw)NzJCannot call a coroutine function synchronously. Use `@async_tool` instead. Input must be a dictionary, got Invalid arguments for function rLrrir~r TypeErrorr,r>rr rrValidationError ValueErrorrXr7rPes r<rTzBetaFunctionTool.call s ty ) ) mkll lu~~ WUtE{{?SUUVV V S+4+??d3.>.>?? ?' S S SJtyJJKKQR R SsA88B$BB$Nr^r>r?r@rTrLr=r<rr . S S S S S Sr=rceZdZddZdS)BetaAsyncFunctionToolrPrQr'r#c^Kt|jstdt|s$t dt |j |jditt|d{VS#tj $r}td|j |d}~wwxYw)NzGCannot call a synchronous function asynchronously. Use `@tool` instead.rrrLrrs r<rTzBetaAsyncFunctionTool.calls"49-- jhii iu~~ WUtE{{?SUUVV V S11EEDe4D4DEEEEEEEE E' S S SJtyJJKKQR R Ss%BB,B''B,Nr^rrLr=r<rrrr=rfnrQr'boolcJt|dd}|duot|S)uTrue when ``fn`` is a function produced by :func:`contextlib.contextmanager`. ``contextmanager`` wraps the generator function with ``functools.wraps``, so the original generator function is reachable as ``__wrapped__`` — the same signal :mod:`inspect` itself uses. We never call ``fn`` to find out, so a plain tool function is never accidentally invoked during detection. __wrapped__N)getattrrrwrappeds r<_is_sync_cm_factoryr%s.b-..G $  ?#6w#?#??r=cJt|dd}|duot|S)zRTrue when ``fn`` is a function produced by :func:`contextlib.asynccontextmanager`.rN)rrrs r<_is_async_cm_factoryr1s,b-..G $  >#5g#>#>>r=toolr(c LKt|ddpt|dd}|e |}t|r|d{VnB#t$r5}tdt|dd|Yd}~nd}~wwxYwt|dd}| t|dd}||dddd{VdS|ddddS#t$r6}td t|dd|Yd}~dSd}~wwxYwdS) uRun a runnable tool's optional cleanup. Drives the legacy ``aclose`` / ``close`` attribute (awaited if it returns an awaitable) and, when the tool was defined as a context manager via :func:`beta_tool` / :func:`beta_async_tool`, its ``__exit__`` / ``__aexit__``. Both run when both are present — the context-manager support is purely additive to ``close``. Exceptions are logged, never raised, so one tool's bad cleanup can't abort another tool's. acloseNrlz"tool.close failed tool=%s error=%srX?rm __aexit__z4tool context-manager cleanup failed tool=%s error=%s)rr Exceptionlogwarning__exit__)rcloserresultrcmaexits r<aclose_runnable_toolr7sT8T * * JgdGT.J.JF  ]VXXF6""   ] ] ] KKX>XZ[ \ \ \ \ \ \ \ \ ] )4 0 0B ~ oB T22E eD$----------- D$----- o o o KKNPWX\^dfiPjPjlm n n n n n n n n n o~s5!A B +BB  &C!C!! D!++DD!riBetaFunctionTool[FunctionT]cdSrKrLrs r< beta_toolrVs?Bsr=rnrXrurjrkrvrorwrprxrqryrrrsrzrtc dSrKrL rirXrjrkrorprqrrrsrts r<rrZs #&#r=2Callable[[FunctionT], BetaFunctionTool[FunctionT]]c dSrKrLrns r<rrms :=r=FunctionT | NonePBetaFunctionTool[FunctionT] | Callable[[FunctionT], BetaFunctionTool[FunctionT]]c  tjrtdd f d } | | |S| S) aFCreate 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: ... r|rrEr'rc  t|rtdt|rtt|}|} t tt|    }n*#t$r|j tj wxYw||_ |St |    S)Nzi@beta_tool was applied to an @asynccontextmanager; use @beta_async_tool for an async context-manager toolrn) rrrr r __enter__rrE BaseExceptionrsysexc_inform) rrinnerrrqrprorjrrrsrkrXrts r<_makezbeta_tool.._makes  # # I  r " "  c2BLLNNE 'E** +!-"/"/$3*?#1!   !    S\^^,,   %'D !K #%''+"7)    s !,B'B5N)rrEr'rrr}r~ rirXrjrkrorprqrrrsrtrs ````````` r<rrs:QOPPP, , , , , , , , , , , , , , \ uT{{ Lr=%BetaAsyncFunctionTool[AsyncFunctionT]cdSrKrLrs r<beta_async_toolrsTWTWr=c dSrKrLrs r<rrs -0Cr=ACallable[[AsyncFunctionT], BetaAsyncFunctionTool[AsyncFunctionT]]c dSrKrLrns r<rrs ILr=AsyncFunctionT | NoneiBetaAsyncFunctionTool[AsyncFunctionT] | Callable[[AsyncFunctionT], BetaAsyncFunctionTool[AsyncFunctionT]]c  tjrtdd f d } | | |S| S) aUCreate 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: ... r|rrGr'rc 2 t|rtdt|r̉tdtt|dddt jgdfd dfd }pt|d d |_  nt|d d|_ ttt|    } ||St|    S)Nza@beta_async_tool was applied to a @contextmanager; use @beta_tool for a sync context-manager toolzan @asynccontextmanager tool needs an explicit input_schema= (its parameters can't be inferred until the context manager is entered)F) validatedenteredr'rcKdsx4d{VdsCd{V}tj|d<dd<d_ dddd{Vn#1d{VswxYwYdS)NrrTr) __aenter__rrrm)rr enter_lockstatetool_boxs r<_enteredz0beta_async_tool.._make.._entered1s2Y'>)>>>>>>>>$Y/>*,--//$9$9$9$9$9$9E191G1N1NE+./3E),<>HQK8=>>>>>>>>>>>>>>>>>>>>>>>>>>>[))sA A33 A=A=kwargsr#cjKd{V}tt|di|d{VS)NrL)r r#)r rr s r<_lazyz-beta_async_tool.._make.._lazy=sW"*(**,,,,,, 6ii>Q>Q&>Q>Q8Q8Q8Q8Q8Q8QRRRr=r>rrArn)r'r)r rr'r#) rrrr ranyioLockrr>rArrGr3)rr rr rrrrrqrprorjrrrsrkrXrts @@@@@r<rzbeta_async_tool.._makes r " " s   # #/  #^c2B265$I$IEJDFH * * * * * * * * * S S S S S S"DWRV%D%DEN+6+BKKPRT]_cHdHdEM(^U++')++ /&;-   D OOD ! ! !K$ #%''+"7)    r=N)rrGr'rrrs ````````` r<rrs:QOPPP@ @ @ @ @ @ @ @ @ @ @ @ @ @ D uT{{ Lr=)rrQr'r)rrQr'r()rirEr'r)rirErXrurjrurkrvrorwrprxrqryrrrwrsrzrtrwr'r)rXrurjrurkrvrorwrprxrqryrrrwrsrzrtrwr'rrK)rirrXrurjrurkrvrorwrprxrqryrrrwrsrzrtrwr'r)rirGr'r)rirGrXrurjrurkrvrorwrprxrqryrrrwrsrzrtrwr'r)rXrurjrurkrvrorwrprxrqryrrrwrsrzrtrwr'r)rirrXrurjrurkrvrorwrprxrqryrrrwrsrzrtrwr'r)J __future__rrloggingabcrrtypingrrrr r r r r rinspectrrrrcollections.abcrtyping_extensionsrrrr rrrrr_utilsrr_modelsr types.betarrr _utils._utilsr types.tool_paramr!'types.beta.beta_tool_result_block_paramr" BetaContent getLoggerr>rr1r#rBrr%FunctionrE AsyncFunctionrGrIrcrhrrrrrrrBetaRunnableToolBetaAsyncRunnableToolrLr=r<r"s""""""" ########^^^^^^^^^^^^^^^^^^^^^^]]]]]]]]]]]]%%%%%%:::::::::: &&&&&&""""""[[[[[[[[[[&&&&&&++++++MMMMMMg!!(-c8K3H.H(IIIII D C33 4 GKx 0 0 0 iS2L(LMMN )???     c        3   a5a5a5a5a5wy)a5a5a5H S S S S S' 2 S S S S S S S S,^< S S S @ @ @ @???? oooo> BBB B "9=!%;?)-9=&&&&& &$ "9=!%;?)-9====== =$"Q"9=!%;?)-9=QQQQQQh WWW W "9=!%;?)-9=00000 0$ "9=!%;?)-9=LLLLL L$#'e"9=!%;?)-9=eeeeeeP)#.0GGH3C8:VVWr=