鎒jh3dZddlZddlZddlZddlZddlZddlmZmZddl Z ddl mZddl m Z dedefdedzfd Zdedefd ededeffd ZGd d ZdedefdZGddZdS)uIn-process tool runner for the Google Antigravity SDK. Tools are Python callables that run directly in the SDK process. The ToolRunner is a registry and executor — it holds references to tool functions and invokes them by name when requested. HOW tool calls reach the runner (callback server, direct invocation, RPC bridge) is a connection strategy concern, not a tool runner concern. ToolContext injection is handled here: at registration time the runner inspects each tool's signature for a ``ToolContext``-typed parameter and caches the result. At execution time, the context is injected automatically. Schema generation (``get_public_callable``) strips injectable parameters so the model never sees them. N)AnyCallable)types) tool_contextfn.returnc|}t|tr|j}t|t tj|}n#t t tf$rYdSwxYw|D]r\}}|dkr |tj ur|cStj |}|tj us|tjur$tj tj|vr|cSsdS)uReturns the name of the ToolContext-typed parameter, if any. Uses ``typing.get_type_hints`` to resolve annotations — including stringified ones from ``from __future__ import annotations`` — and checks for an exact match against ``ToolContext``. Args: fn: The callable to inspect. If it's a ``ToolWithSchema``, the inner ``.fn`` is used. Returns: The parameter name, or None if no ToolContext parameter is found. Nr) isinstanceToolWithSchemartypingget_type_hints TypeError NameErrorAttributeErroritemstool_context_module ToolContext get_originUnion std_types UnionTypeget_args)rtargethintsnameannorigins RC:\Projects\DSCons\.venv\Lib\site-packages\google\antigravity\tools\tool_runner.py_find_context_paramr+s  &6>** YF 6>**  !& ) )EE Y / 44;;==  idC x !--- kkk  s # #F 9+>!>!>  (FOC,@,@ @ @ sA A%$A% context_paramcttr(ttjjSt j}fd|jD}| |}tr tj fd}ntj fd}t|d||S)aReturns a proxy callable with the injectable parameter removed. The proxy has the same ``__name__``, ``__doc__``, and a modified ``__signature__`` that excludes the ``context_param``. This is used for schema generation so the model never sees the injected parameter. Args: fn: The original callable. context_param: Name of the parameter to hide. Returns: A wrapper callable with a cleaned signature. c&g|] \}}|k |Sr#).0npr s r z)_make_public_callable..ds'KKKda]8J8J8J8J8J) parametersc$Kdi|d{VSNr#r#kwargsrs r_proxyz%_make_public_callable.._proxyis+2<<<<      r(cdi|Sr+r#r,s rr.z%_make_public_callable.._proxyos R\\&\\r( __signature__)r r _make_public_callabler input_schemainspect signaturer)rreplace _is_async functoolswrapssetattr)rr sig new_params public_sigr.s`` rr1r1Ns N## be]33R_   "#KKKKcn2244KKK*{{j{11*r]] _R      _R &/:... -r(cReZdZdZdedefdeeeffdZdedefdZ d S) r z3Wrapper for callables with an explicit JSON Schema.r.r2c||_||_t|ddpt|j|_t|dd|_dS)N__name____doc__)rr2getattrtyper?r@)selfrr2s r__init__zToolWithSchema.__init__zsIDG$DB D11FT"XX5FDM2y$//DLLLr(r-rc |jdi|Sr+)r)rCr-s r__call__zToolWithSchema.__call__s 47  V  r(N) r? __module__ __qualname__r@rrdictstrrDrFr#r(rr r wso;;0#s(+04S>0000 ssr(r callable_objct|trt|jSt j|p(t |dot j|jS)zGReturns True if the callable is async (coroutine function or __call__).rF)r r r6rr3iscoroutinefunctionhasattrrF)rKs rr6r6s_ n--& \_ % %%  $\ 2 2  lJ''=  %l&; < <r(ceZdZdZddeejdzfdZdej ddfdZ ddejd e dzddfd Z d e ddfd Z edee fd Zedee ejffd Zde dedeffdZdedefdedefdZde dee efdee effdZdedefdee efdee effdZde dedefdZdeejdeejfdZdS) ToolRunneraRegistry and executor for in-process Python tools. Tools are registered by name and executed on demand. Both sync and async tools are supported. Tools that declare a ``ToolContext``-typed parameter receive the context automatically at execution time. Ntoolscli|_d|_i|_|r|D]}||dSdSN)_tools_context_context_paramsregister)rCrQtools rrDzToolRunner.__init__sZ/1DK<@DM,.D $ dr(ctxrc||_dS)ztSets the ToolContext for injection into tools that request it. Args: ctx: The ToolContext to inject. N)rU)rCrYs r set_contextzToolRunner.set_contexts DMMMr(rXrc|p$t|ddpt|j}||jvrt d|d||j|<t |}| ||j|<dSdS)aRegisters a tool by name. At registration time, the tool's signature is inspected for a ``ToolContext``-typed parameter. If found, the parameter name is cached for injection at execution time. Args: tool: The callable to register. name: Optional name override. Defaults to tool.__name__. Raises: ValueError: If a tool with the same name is already registered. r?NTool 'z' is already registered.)rArBr?rT ValueErrorrrV)rCrXr tool_name ctx_params rrWzToolRunner.registersNj$77N4::;NIDK C CCC D DD!DK $D))I(1d9%%%r(c||jvrtd|d|j|=|j|ddS)zRemoves a tool by name. Args: name: The name of the tool to remove. Raises: KeyError: If no tool with the given name is registered. r]' is not registered.N)rTKeyErrorrVpop)rCrs r unregisterzToolRunner.unregistersT 4; 8d888 9 99 DT4(((((r(cNt|jS)z"The names of all registered tools.)listrTkeysrCs r tool_nameszToolRunner.tool_namess     "" # ##r(c*t|jS)z*A copy of the registered tools dictionary.)rIrTris rrQzToolRunner.toolss   r(r_.c||jvrtd|d|j|}|j|}||St ||S)aReturns a callable with injectable params hidden from the signature. Connections use this to generate tool schemas for the model without exposing internal-only parameters like ``ToolContext``. Args: tool_name: The name of the registered tool. Returns: The original callable if no context parameter, otherwise a proxy callable with the context parameter removed from the signature. Raises: KeyError: If no tool with the given name is registered. r]rb)rTrcrVgetr1)rCr_rXr`s rget_public_callablezToolRunner.get_public_callablesh  ## =i=== > >> ;y !D$((33I k y 1 11r(rr-cKt|stj|fi|d{V}n|di|}tj|r|d{VS|S)zAExecutes a callable, running sync functions in a separate thread.Nr#)r6asyncio to_thread iscoroutine)rCrr-results r _execute_fnzToolRunner._execute_fns{ R==&r44V44444444ffr||F||f6""\\\\\\ Mr(cn|j|}||j||vr i|||jiS|S)avReturns kwargs augmented with ToolContext if the tool requests it. Returns a new dict when injection occurs; returns the original dict unchanged otherwise (no unnecessary copies). Args: tool_name: The registered tool name. kwargs: The original keyword arguments. Returns: The kwargs dict, potentially augmented with the ToolContext. )rVrmrU)rCr_r-r`s r_inject_contextzToolRunner._inject_contextsN$((33I!: & 3&3)T]333 Mr(c0|}t|tr|j}t|t tj|}n#t t f$r|cYSwxYw tj|}n#t ttf$ri}YnwxYwi}|j D]\}}||vr |j tjjtjjfvr ||||<?||} |||j} | tjjus| | ||<} t)j| } | | ||<#t.$r| ||<YwxYw| D]\} } | |vr| || <|S)zLCoerces keyword arguments to match function type annotations using pydantic.)r r rr3r4r^rr r rrr)rkind ParameterVAR_POSITIONAL VAR_KEYWORDrm annotationemptypydantic TypeAdaptervalidate_python Exception)rCrr-rr:rcoercedrparamvalradapterkvs r _coerce_argszToolRunner._coerce_argssF V^ , ,yf V^ , ,  f % %cc  " mmm#F++ee y. 1eeeG~++-- e V      *   '  t   4Lc IIdE, - -c !' ' '3; &s++//44   1 '   Ns5A A A $A99BB1,EE0/E0cK||jvrtd|d|j|}|||}|||}|j|fi|d{VS)aExecutes a registered tool by name. If the tool declares a ``ToolContext`` parameter and a context has been set via ``set_context()``, the context is injected automatically. Args: tool_name: The name of the tool to execute. **kwargs: Arguments to pass to the tool. Returns: The tool's return value. Raises: KeyError: If no tool with the given name is registered. r]rbN)rTrcrrvrt)rCr_r-tool_fns rexecutezToolRunner.execute>s  ## =i=== > >>k)$G   w / /F  ! !)V 4 4F!!'44V44 4 4 4 4 4 44r( tool_callscKdtjdtjffd tt jfd|Dd{VS)aExecutes a batch of tool calls concurrently and returns structured results. Tool calls are executed in parallel via ``asyncio.gather``. Unknown tools and execution failures produce ToolResult with an error message rather than raising. Note: tools execute concurrently; callers must not depend on sequential side-effect ordering. Args: tool_calls: List of ToolCall objects. Returns: A list of ToolResult, one per input tool call, in the same order. tcrc K |jjvr6tj|j|j|j|jd|jdSj|jfi|jd{V}tj|j|j|j|j|S#t$rE}tj|j|j|j|jt||cYd}~Sd}~wwxYw)NzUnknown tool: '')idstep_id server_namererror)rrrrrs)rrrrr exception) rrTr ToolResultrrrrargsrrJ)rrserCs r _execute_onez3ToolRunner.process_tool_calls.._execute_onejs/ 7$+ % %!j.70bg000     $t|BG77rw77777777uJ        uJa&&           s%AB A B C#:CC#C#c&g|] }|Sr#r#)r$rrs rr'z1ToolRunner.process_tool_calls..s#&M&M&MB||B'7'7&M&M&Mr(N)rToolCallrrgrpgather)rCrrs` @rprocess_tool_callszToolRunner.process_tool_callsVsw( u~ %2B      < gn&M&M&M&M*&M&M&MNNNNNNN O OOr(rS)r?rGrHr@rgr PythonToolrDrrr[rJrWrepropertyrjrIrQrrrnrtrvrrrrrr#r(rrPrPslD!12T90<225+23:222220 )S )T ) ) ) ) $$s)$$$ 8$ T#u//0 82328CH3E22220 (38"4      $(cN CH~*,c",,0cN, CH~,,,,\5S5C5C555502Pu~&2P E 2P2P2P2P2P2Pr(rP)r@rpr7r3rrr rrr~google.antigravitygoogle.antigravity.toolsrrrJrr1r boolr6rPr#r(rrs  $$$$$$HHHHHH HS#X. 3:    F&c&+.& c3h&&&&R        CDzPzPzPzPzPzPzPzPzPzPr(