"j%FSrSSKJr SSKrSSKJrJrJrJrJ r SSK J r SSK J r SSKJrJrJrJr S S KJr S S KJr S S KJr S S KJr S SKJrJr /SQr"SS\ 5r "SS\ 5r!\"S\ S9r"SSjr#SSjr$S Sjr%S!Sjr&S"Sjr'S#Sjr(S$Sjr)S%Sjr*g)&a1Shared tool-dispatch helpers for the tool runners. Both `client.beta.messages.tool_runner` (the Messages tool runner) and `client.beta.sessions.events.tool_runner` (the sessions-side `anthropic.lib.tools._beta_session_runner.SessionToolRunner`) do the same three small things: index the supplied tools by name, run a runnable tool over a JSON input, and turn an exception raised by a tool into tool-result content. Those steps are factored out here so the two runners stay consistent instead of each carrying its own copy. Consumed by the runner helpers only. ) annotationsN)UnionTypeVarIterable Awaitablecast)Protocol)run_sync) ToolErrorBetaFunctionToolBetaBuiltinFunctionToolBetaFunctionToolResultType)BetaMessageParam)BetaCompactionBlock)BetaContentBlockParam) BetaRequestToolRemovalBlockParam)Tool!BetaRequestToolAdditionBlockParam) tool_registrytool_error_contentrun_runnable_toolavailable_tool_namesc,\rSrSrSr\SSj5rSrg) _NamedTool!u@Anything with a `name` — the shape `tool_registry` indexes on.cgN)selfs _/home/mande/repo/quber/.venv/lib/python3.13/site-packages/anthropic/lib/tools/_tool_dispatch.pyname_NamedTool.name$sr N)returnstr)__name__ __module__ __qualname____firstlineno____doc__propertyr#__static_attributes__r r%r"rr!sJ r%rc"\rSrSrSrSSjrSrg) _CallableTool(zbA runnable tool: `call` may be sync or async (it returns either the result or an awaitable of it).cgrr )r!inputs r"call_CallableTool.call,sorr%r N)r3objectr&zHUnion[BetaFunctionToolResultType, Awaitable[BetaFunctionToolResultType]])r(r)r*r+r,r4r.r r%r"r0r0(s &sr%r0 NamedToolT)boundcFUVs0sHoRU_M sn$s snf)zIndex `tools` by their `name` for O(1) dispatch lookup. On a duplicate name the later tool wins, matching a plain dict comprehension. )r#)toolstools r"rr2s" ). .IItO .. .sc[U5nUHfnUSn[U[5(aMUHAnUSS:Xa [XR5 MUSS:XdM$[ U5Hn[Xb5 M MC Mh U$)aFold mid-conversation `tool_removal` / `tool_addition` blocks over the locally runnable `tool_names`. These blocks arrive in `role: "system"` messages, and in the `tool_changes` of a `compaction` block, which stands in for the system messages of the turns it summarized. A `tool_reference` or a by-value `tool_definition` can name a locally runnable tool; MCP references execute server-side, so they (and any unknown block or tool type) are ignored rather than raising. contentrolesystem assistant)set isinstancer'_apply_tool_change_compaction_tool_changes)messages tool_names availablemessager=blockchanges r"rr:szJI)$ gs # # Ev(*"54K/6u=F&v9>   r%c,[U[5(aBUR=(d SVs/sH!n[[UR 55PM# sn$[U[ 5(a#USS:XaURS5=(d S$gs snf)zThe ``tool_changes`` of a ``compaction`` block, whichever shape it has in history. A caller-written block is a dict; one the runner echoed from a response is still the response model, with response-model entries. r type compaction tool_changes)rBrrNrrto_dictdictget)rIrJs r"rDrDSs| %,--LQL^L^LdbdLdeLd&*FNN,<=Ldee%5=L#@yy(.B. fs(Bcl[U[5(dgUSS:Xd USS:Xa [X5 gg)zEApply a single `tool_removal` / `tool_addition` block to `available`.NrL tool_removal tool_addition)rBrP_apply_tool_reference_change)rIrGs r"rCrC`s9 eT " "  V}&%-?*J$U6+Kr%c[US5nUcgUSS:XaURU5 gURU5 g)zAFold one `tool_removal` / `tool_addition` block into `available`.r;NrLrS)_changed_tool_namediscardadd)rIrGr#s r"rUrUks@ eFm ,D | V}&$ dr%cUSS:XaUS$USS:Xa7[SUS5RS5n[U[5(aU$S$g)a The locally runnable tool name a tool-change ``tool`` resolves to. `tool_reference` names one directly and `tool_definition` carries one by value; MCP references execute server-side, and unknown types are ignored (forward compatibility), so those resolve to `None`. rLtool_referencer#tool_definitiondict[str, object] definitionN)rrQrBr')r;r#s r"rWrWxs_ F|''F| F|(('l);<@@H!$,,t6$6 r%cZ[U[5(a UR$[U5$)zRender an exception raised by a tool as tool-result content. A `ToolError` carries its own structured content; anything else is rendered with `repr` (which, unlike `str`, keeps the exception type). The caller owns the `is_error` flag and any logging. )rBr r=repr)excs r"rrs%#y!!{{ 9r%c# [U[[45(a[URUSS9IShvN $UR U5n[ R "U5(a UIShvN $U$N<N7f)zCall `tool` with `input`, awaiting the result if the tool is async. Sync tools run on a worker thread. If the caller cancels (for example on a timeout), the thread is left to finish on its own and its result is dropped. T)abandon_on_cancelN)rBr rr r4inspect isawaitable)r;r3results r"rrsh$)+BCDDdii$GGG YYu F6""| M Hs!4A7A35A7,A5-A75A7)r:zIterable[NamedToolT]r&zdict[str, NamedToolT])rEzIterable[BetaMessageParam]rFz Iterable[str]r&set[str])rIrr&zIterable[BetaContentBlockParam])rIrrGrgr&None)rIzJUnion[BetaRequestToolRemovalBlockParam, BetaRequestToolAdditionBlockParam]rGrgr&rh)r;_ToolChangeToolr&z str | None)ra BaseExceptionr&r)r;r0r3r]r&r)+r, __future__rrdtypingrrrrrtyping_extensionsr anyio.to_threadr _beta_functionsr r rrtypes.beta.beta_message_paramr types.beta.beta_compaction_blockr#types.beta.beta_content_block_paramr0types.beta.beta_request_tool_removal_block_paramr1types.beta.beta_request_tool_addition_block_paramrrir__all__rr0r7rrrDrCrUrWrrr r%r"rvs #<<&$mm=CH` _sHs\ 4 /2 7  U bj      r%