hyf

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

query_rewrite.mojo (4143B)

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