{h$R ddlZddlZddlmZmZmZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZddlZddlmZmZmZmZmZmZddlmZddlmZdd lmZm Z dd lm!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'ddl(m)Z)m*Z*e%e+Z,GddeZ-GddeZ.GddeZ/ d,dede fdee0de1dzde/fdZ2de de0dede3e4edze5e0e fdze1ffdZ6de4e de4efd Z7d!e4e de4efd"Z8de0de dede4efd#Z9de0d$e de4efd%Z:de d&e5e0e fde fd'Z;d(ede fdejxfd)Z=d*e dee)fd+Z>y)-N) AwaitableCallableSequence)chain) GenericAlias) AnnotatedAny ForwardRefcastget_args get_originget_type_hints) BaseModel ConfigDictField RootModelWithJsonSchema create_model)eval_type_backport) FieldInfo)GenerateJsonSchemaJsonSchemaWarningKind)PydanticUndefined)InvalidSignature) get_logger)Image) ContentBlock TextContentc$eZdZdZdededdfdZy)StrictJsonSchemazA JSON schema generator that raises exceptions instead of emitting warnings. This is used to detect non-serializable types during schema generation. kinddetailreturnNc$td|d|)NzJSON schema warning: z - ) ValueError)selfr!r"s k/var/www/html/hubwallet-dev/venv/lib/python3.12/site-packages/mcp/server/fastmcp/utilities/func_metadata.py emit_warningzStrictJsonSchema.emit_warning$s0c&BCC)__name__ __module__ __qualname____doc__rstrr(r)r'r r s& D!6DDDr)r c8eZdZdZdeeeffdZedZ y) ArgModelBasez1A model representing the arguments to a function.r#ci}|jjjD]0\}}t||}|jr |jn|}|||<2|S)zReturn a dict of the model's fields, one level deep. That is, sub-models etc are not dumped - they are kept as pydantic models. ) __class__ model_fieldsitemsgetattralias)r&kwargs field_name field_infovalue output_names r'model_dump_one_levelz!ArgModelBase.model_dump_one_level,sb "$&*nn&A&A&G&G&I ( "J D*-E.8.>.>***JK"'F;   (  r)Tarbitrary_types_allowedN) r*r+r,r-dictr.r r=r model_configr/r)r'r1r1)s(; d38n  $Lr)r1c "eZdZUeeeedfed<dZe e e fdzed<dZ eee edfdzed<dZeed<dede ee zfd ed e e e fd e e e fdzd e f d Zde d e fdZde e e fd e e e ffdZedZy) FuncMetadataN arg_model output_schema output_modelF wrap_outputfn. fn_is_asyncarguments_to_validatearguments_to_pass_directlyr#cK|j|}|jj|}|j}||xsiz}|r|di|d{S|di|S7 w)zCall the given function with arguments validated and injected. Arguments are first attempted to be parsed from JSON, then validated against the argument model, before being passed to the function. Nr/)pre_parse_jsonrDmodel_validater=)r&rHrIrJrKarguments_pre_parsedarguments_parsed_modelarguments_parsed_dicts r'call_fn_with_arg_validationz(FuncMetadata.call_fn_with_arg_validationDsy $223HI!%!>!>?S!T 6 K K M!;!ArA 4344 4.-. .5sAA$A" A$resultct|}|j|S|jrd|i}|jJd|jj |}|j dd}||fS)aB Convert the result of a function call to the appropriate format for the lowlevel server tool call handler: - If output_model is None, return the unstructured content directly. - If output_model is not None, convert the result to structured output format (dict[str, Any]) and return both unstructured and structured content. Note: we return unstructured content here **even though the lowlevel server tool call handler provides generic backwards compatibility serialization of structured content**. This is for FastMCP backwards compatibility: we need to retain FastMCP's ad hoc conversion logic for constructing unstructured output from function return values, whereas the lowlevel server simply serializes the structured output. rSz4Output model must be set if output schema is definedjsonT)modeby_alias)_convert_to_contentrErGrFrN model_dump)r&rSunstructured_content validatedstructured_contents r'convert_resultzFuncMetadata.convert_result[s 36:    %' '"F+$$0 h2h h0))88@I!*!5!56D!5!Q (*<= =r)datacB|j}i}|jjjD]&\}}|||<|js|||j<(|j D]p}||vr||}t ||ts!|jtus4 tj||}t |ttztzrl|||<r|j |j k(sJ|S#tj$rYwxYw)aPre-parse data from JSON. Return a dict with same keys as input but with values parsed from JSON if appropriate. This is to handle cases like `["a", "b", "c"]` being passed in as JSON inside a string rather than an actual list. Claude desktop is prone to this - in fact it seems incapable of NOT doing this. For sub-models, it tends to pass dicts (JSON objects) as JSON strings, which can be pre-parsed here. )copyrDr4r5r7keys isinstancer. annotationrUloadsJSONDecodeErrorintfloat)r&r^new_datakey_to_field_infor9r:data_key pre_parseds r'rMzFuncMetadata.pre_parse_jsonys$99;35&*nn&A&A&G&G&I A "J ,6 j )6@!*"2"23  A   0H00*84J$x.#.:3H3HPS3S!%DN!;Jj#)e*;<%/" 0 }}$))+---++s%DDDTr>)r*r+r,rtyper1r__annotations__rEr@r.r rFrrGboolrrrRr]rMrrAr/r)r'rCrC>sl+^D-AABB+/M4S>D(/LPL)DO^D-AABTIPK/ S# #.. /// $CH~ / %)cNT$9 / /.>S>S><&4S>&d38n&P $Lr)rCfunc. skip_namesstructured_outputr#c Pt|}|j}i}t|di}|jD]}|jj dr&t d|jd|jd|j|vrT|j}|Ktdt|jtjjur |jntf}|tjjur.tt tt#|jdd f}t%j&t)|||jtjjur |jnt} t+t,|jrwt/tt,|jrT|j| _|j| _|j| _d |j} | j| f|| <n| j| f||j<t7|jd fi|d t8i} |d ur t;| S|j<tjjur|durt d|jdt%j>t)|j<|} | j}tA||j| \} }}| |durt d|jd|dt;| || |S)a Given a function, return metadata including a pydantic model representing its signature. The use case for this is ``` meta = func_metadata(func) validated_args = meta.arg_model.model_validate(some_raw_data_dict) return func(**validated_args.model_dump_one_level()) ``` **critically** it also provides pre-parse helper to attempt to parse things from JSON. Args: func: The function to convert to a pydantic model skip_names: A list of parameter names to skip. These will not be included in the model. structured_output: Controls whether the tool's output is structured or unstructured - If None, auto-detects based on the function's return type annotation - If True, unconditionally creates a structured tool (return type annotation permitting) - If False, unconditionally creates an unstructured tool If structured, creates a Pydantic model for the function's result based on its annotation. Supports various return types: - BaseModel subclasses (used directly) - Primitive types (str, int, float, bool, bytes, None) - wrapped in a model with a 'result' field - TypedDict - converted to a Pydantic model with same fields - Dataclasses and other annotated classes - converted to Pydantic models - Generic types (list, dict, Union, etc.) - wrapped in a model with a 'result' field Returns: A FuncMetadata object containing: - arg_model: A pydantic model representing the function's arguments - output_model: A pydantic model for the return type if output is structured - output_conversion: Records how function output should be converted before returning. __globals___z Parameter z of z cannot start with '_'N)defaultstring)titlerlfield_ Arguments__base__F)rDTz Function z2: return annotation required for structured outputz: return type z* is not serializable for structured output)rDrErFrG)!_get_typed_signature parametersr6valuesname startswithrr*rcrrruinspect Parameteremptyrr rrfrom_annotated_attribute_get_typed_annotationhasattrrcallabler7validation_aliasserialization_aliasrr1rCreturn_annotationfrom_annotation_try_create_model_and_schema)rorprqsigparamsdynamic_pydantic_model_paramsglobalnsparamrcr: internal_namearguments_model output_inforFrErGs r' func_metadatarsT t $C ^^F46!t]B/H( ::  %"Z |4 Nd#ef f :: # %%   "u}}GDUDUD[D[/[emmarsuJ **00 0"XFGIJ77 !*h 7"]]'2C2C2I2IIEMMO`  9ejj )hwy%**7U.V$zzJ */**J '-2ZZJ *$UZZL1M} t:j=d|d |d t| j>d | Yd} ~ y d} ~ wwxYw) a4Try to create a model and schema for the given annotation without warnings. Returns: tuple of (model or None, schema or None, wrap_output) Model and schema are None if warnings occur or creation fails. wrap_output is True if the result needs to be wrapped in {"result": ...} NFTrrm)schema_generatorzCannot create schema for type z in z: )NNF) _create_wrapped_modelrbrr r@r lenr._create_dict_modelrlr r issubclassrr_create_model_from_typeddictrfrgrnbytesr_create_model_from_classmodel_json_schemar TypeErrorr% pydantic_core SchemaErrorValidationErrorloggerinfor*) rcrr:modelrGoriginargstype_annotation type_hintsschemaes r'rrs EK%iZH  J -J' T>J'D4yA~$q'S.*9jA.iZP" *)ZLEK J %%)$s)Z%@ j) ,E_&7 8Z TX=Y0AECeT5$t*E E))ZLEK(8J0A&iZH   %,,>N,OFfk)) :}'@'@-B_B_` % KK8 D SUVZ[\V]VfVfUggijkilm n$ %sE,,-G4GGclsc2t|}i}|jD]O\}}|jdrt||t}t j ||}|j|f||<QGddt}t|jfi|d|iS)ajCreate a Pydantic model from an ordinary class. The created model will: - Have the same name as the class - Have fields with the same names and types as the class's fields - Include all fields whose type does not include None in the set of required fields Precondition: cls must have type hints (i.e., get_type_hints(cls) is non-empty) rtceZdZedZy)0_create_model_from_class..BaseWithConfigT)from_attributesN)r*r+r,rrAr/r)r'BaseWithConfigrs !$7 r)rrz) rr5rr6rrrrcrrr*)rrr4r9 field_typerur:rs r'rrvs $J#%L","2"2"4G J   % #z+<=77 GL $.$9$9:#F Z G88  N N~ NNr)td_typec2t|}t|dt|j}i}|j D]6\}}t j |}||vrd|_|j|f||<8t|jfi|dtiS)zzCreate a Pydantic model from a TypedDict. The created model will have the same name and fields as the TypedDict. __required_keys__Nrz) rr6setrar5rrrurcrr*r)rr required_keysr4r9rr:s r'rrs  (JG%8#joo>O:PQM#%L","2"2"4 G J..z: ] *"&J $.$9$9:#F Z  G (( ML M9 MMr)cN|d}| td}t|||ftS)zCreate a model that wraps a type in a 'result' field. This is used for primitive types, generic types like list/dict, etc. OutputN)rSrz)rlrr)rrcr: model_names r'rrs5 ;f%J$Z  J +Ci XXr)dict_annotationcRGddt|}|d|_|d|_|S)z*Create a RootModel for dict[str, T] types.c eZdZy)%_create_dict_model..DictModelN)r*r+r,r/r)r' DictModelrs r)r DictOutput)rr*r,)rrrs r'rrs9 Io. &;j1I ){*5I r)rc dtdtttfdtttfdtttffd}t |tr*t |}||||\}}|durtd||S)Nr;rlocalnsr#cH t|||dfS#t$r|dfcYSwxYw)NTF)r NameError)r;rrs r' try_eval_typez,_get_typed_annotation..try_eval_types4 %eXw?E E %<  s  !!Fz#Unable to evaluate type annotation )r r@r.tuplernrbr r)rcrrstatuss r'rrs S DcN T#s(^ X]^acg^gXh *c" + *:xJ F U?"%H #UV V r)callc tj|}t|di}|jj Dcgc]M}tj |j |j|jt|j|O}}t|j|}tj||}|Scc}w)z:Get function signature while evaluating forward referencesrs)r~r!rurc)r) r signaturer6r|r}rr~r!rurrcr Signature)rrrr typed_params typed_returntyped_signatures r'r{r{s!!$'It]B/H))002  MM,U-=-=xH  L))D)DhOL'' UO sACrScz|gSt|tr|gSt|tr|jgSt|tt zr%t t jd|DSt|ts*tj|tdj}td|gS)aY Convert a result to a sequence of content objects. Note: This conversion logic comes from previous versions of FastMCP and is being retained for purposes of backwards compatibility. It produces different unstructured output than the lowlevel server tool call handler, which just serializes structured content verbatim. c32K|]}t|yw)N)rX).0items r' z&_convert_to_content..s $D) sr)fallbackindenttext)rlr) rbrrto_image_contentlistrr from_iterabler.rto_jsondecoder)rSs r'rXrXs~ &,'x&% '')**&$,'    "     fc "&&vAFMMO V& 1 22r))r/N)?rrUcollections.abcrrr itertoolsrtypesrtypingrr r r r r rrpydanticrrrrrr pydantic._internal._typing_extrarpydantic.fieldsrpydantic.json_schemarrrmcp.server.fastmcp.exceptionsr$mcp.server.fastmcp.utilities.loggingr"mcp.server.fastmcp.utilities.typesr mcp.typesrrr*rr r1rCr.rnrrrlr@rrrrrrrr{rXr/r)r'rs 99YYY@%J+:;4/ H D)D9*e9eT!#%)v 38 v vd{v vrTT #T1:T 4 ?T !4S>D#8$ >?TnO$s)OYO8N$s)NYN. YS Yc Yy YUYZcUd Y #  Y cT#s(^&xS1g6G6G$3 3 l3r)