hyf

Context-aware query service for Radroots
git clone https://radroots.dev/git/hyf.git
Log | Files | Refs | README | LICENSE

query_rewrite.mojo (4156B)

      1 from std.collections import List, Optional
      2 
      3 from json import Value, loads
      4 
      5 from hyf_core.capabilities.query_analysis import (
      6     QueryAnalysis,
      7     QueryRewriteRequest,
      8     analyze_query_text,
      9     build_deterministic_meta,
     10     parse_query_rewrite_request,
     11     query_signal_tags,
     12     serialize_extracted_filters,
     13     string_array_value,
     14 )
     15 from hyf_core.errors import (
     16     CapabilityResult,
     17     failed_capability,
     18     invalid_input_error,
     19     successful_capability,
     20 )
     21 from hyf_core.provenance import (
     22     CoreResponseMeta,
     23     ExecutionProvenance,
     24     ProvenanceFallback,
     25     ProvenanceSourceRef,
     26 )
     27 from hyf_core.request_context import (
     28     RequestContext,
     29     assisted_execution_requested,
     30 )
     31 
     32 
     33 def build_query_rewrite_output(analysis: QueryAnalysis) raises -> Value:
     34     var output = loads("{}")
     35     output.set("original_text", Value(String(analysis.original_text)))
     36     output.set("normalized_text", Value(String(analysis.normalized_text)))
     37     output.set("rewritten_text", Value(String(analysis.rewritten_text)))
     38     output.set("query_terms", string_array_value(analysis.query_terms))
     39     output.set(
     40         "normalization_signals",
     41         string_array_value(analysis.normalization_signals),
     42     )
     43     output.set("ranking_hints", string_array_value(analysis.ranking_hints))
     44     output.set(
     45         "extracted_filters",
     46         serialize_extracted_filters(analysis.extracted_filters),
     47     )
     48     return output^
     49 
     50 
     51 def _base_source_refs(
     52     context: RequestContext, capability_name: String
     53 ) -> List[ProvenanceSourceRef]:
     54     var source_refs = List[ProvenanceSourceRef]()
     55     source_refs.append(
     56         ProvenanceSourceRef(
     57             source_kind="local_input",
     58             source_ref=capability_name + ":input",
     59         )
     60     )
     61     if context.scope:
     62         source_refs.append(
     63             ProvenanceSourceRef(
     64                 source_kind="request_scope",
     65                 source_ref="request_context.scope",
     66             )
     67         )
     68     return source_refs^
     69 
     70 
     71 def build_query_rewrite_deterministic_fallback_meta(
     72     context: RequestContext,
     73     analysis: QueryAnalysis,
     74     fallback_kind: String,
     75     reason: String,
     76 ) -> CoreResponseMeta:
     77     var provenance: Optional[ExecutionProvenance] = None
     78     if context.return_provenance:
     79         provenance = ExecutionProvenance(
     80             kind="deterministic",
     81             signal_tags=query_signal_tags(analysis),
     82             source_refs=_base_source_refs(context, "query_rewrite"),
     83             fallback=ProvenanceFallback(
     84                 fallback_kind=String(fallback_kind), reason=String(reason)
     85             ),
     86             evidence_set_id=None,
     87         )
     88 
     89     return CoreResponseMeta(
     90         execution_mode="deterministic",
     91         backend="heuristic",
     92         provider=None,
     93         route=None,
     94         model=None,
     95         latency_ms=None,
     96         schema_version=Optional[Int](1),
     97         prompt_version=None,
     98         fallback_kind=Optional[String](String(fallback_kind)),
     99         fallback_reason=Optional[String](String(reason)),
    100         provenance=provenance^,
    101     )
    102 
    103 
    104 def execute_query_rewrite(
    105     input: Value, context: RequestContext
    106 ) raises -> CapabilityResult:
    107     try:
    108         var request: QueryRewriteRequest = parse_query_rewrite_request(input)
    109         var analysis = analyze_query_text(request.text, context)
    110         if assisted_execution_requested(context):
    111             return successful_capability(
    112                 build_query_rewrite_output(analysis),
    113                 meta=build_query_rewrite_deterministic_fallback_meta(
    114                     context,
    115                     analysis,
    116                     "assisted_execution",
    117                     "deferred_bootstrap_runtime",
    118                 ),
    119             )
    120 
    121         var source_refs = List[ProvenanceSourceRef]()
    122         return successful_capability(
    123             build_query_rewrite_output(analysis),
    124             meta=build_deterministic_meta(
    125                 context=context,
    126                 capability_name="query_rewrite",
    127                 signal_tags=query_signal_tags(analysis),
    128                 extra_source_refs=source_refs^,
    129             ),
    130         )
    131     except e:
    132         return failed_capability(invalid_input_error(String(e)))